def integrate( self, age ): # calculate range to integrate over lower_bound = age - self.maxage upper_bound = age - self.minage # if upper_bound is negative then this is a later region and we are working on early ages # If so, return zeros if upper_bound < 0: return ( np.zeros( self.ls.size ), 0 ) # find things in the age range (include a little extra to account for rounding errors) inds = np.where( (self.ages >= lower_bound-age*1e-5) & (self.ages <= upper_bound+age*1e-5) )[0] # simpsons rule is based on intervals, so include the SED one age lower if it exists # otherwise one interval will be missed at every boundary if inds[0] > 0 and np.abs( self.ages[inds[0]] - lower_bound ) > 1e-5*age: inds = np.append( inds[0]-1, inds ) weights = self.sfh_func( age-self.ages[inds] ) # if weights are all zero then there is no star formation in this region and therefore no need to integrate if max( weights ) <= 0: return ( np.zeros( self.ls.size ), 0 ) if self.has_dust: # integrate weights*sed*dust seds = integrate.simps( weights*self.seds[:,inds]*dust_wrapper( self.ages[inds], self.ls ), x=self.ages[inds], even='avg' ) else: # integrate weights*sed seds = integrate.simps( weights*self.seds[:,inds], x=self.ages[inds], even='avg' ) # integrate weights*mass mass = integrate.simps( weights*self.masses[inds], x=self.ages[inds], even='avg' ) if self.has_masses else 0 return ( seds, mass )
def eigenvalue(z, V, psi, m):
"""Calcula um autovalor como E=<Psi|H|Psi>/<Psi|Psi>
onde H = T + V, T eh o operador de energia cinetica em uma dimensao
Params
------
z : array_like
o eixo z
V : array_like
o potencial
psi : array_like
a funcao de onda psi(z)
m : array_like
a massa efetiva m*(z)
Returns
-------
O autovalor E=<Psi|H|Psi>/<Psi|Psi>
"""
dz = np.append(z[1:]-z[:-1], z[1]-z[0])
dz2 = dz**2
h_psi = np.zeros(N, dtype=np.complex_)
for i in range(N):
h_psi[i] = ((0.5/dz2[i])*(1.0/idf(m, i+0.5) +
1.0/idf(m, i-0.5))+V[i])*psi[i]
if i > 0:
h_psi[i] += -(0.5/dz2[i])*(psi[i-1]/idf(m, i-0.5))
if i < N-1:
h_psi[i] += -(0.5/dz2[i])*(psi[i+1]/idf(m, i+0.5))
psi_h_psi = simps(psi.conj()*h_psi, z)
return (psi_h_psi / simps(psi.conj()*psi, z)).real
def weight_CLAP_Data(self, lbda_cent):
"""
Compute the weighting function for the Clap data
to assign a weight due to the particular shape for
the interested fiber arm (which is always the same
for CLAP 1). With this is possible to convert the
CLAP light level from ADUs to W.
INPUT:
lbda_cent: the central wavelength as observed by SNIFS
in Angstrom
OUTPUT:
weight_funct: the weighting function to apply to CLAP light
level to convert the ADU in W
"""
lbd_weight = N.linspace(0.,99.940, 1001)
lbd_line = N.linspace(lbd_weight[0]-lbd_weight[len(lbd_weight)/2],lbd_weight[-1]-lbd_weight[len(lbd_weight)/2],len(lbd_weight))+lbda_cent
clap1_int = N.mean([d(lbd_line) for d in self.clap1_simul], axis=0)
err_clap1_int = N.var([d(lbd_line) for d in self.clap1_simul], axis=0)
integ_weight = integrate.simps(self.Inter1*clap1_int, lbd_line)
sqr_Inter1 = self.Inter1**4
sqr_clap1 = clap1_int**2
Int_func = integrate.simps(self.Inter1, lbd_line)
Int_sqr = integ_weight**2
weight_funct = Int_func/integ_weight
weight_funct_err = ((self.var_Inter1[0]*(Int_sqr+sqr_clap1[0]-2*integ_weight*clap1_int[0])+(sqr_Inter1[0]*err_clap1_int[0]))\
+4*N.sum((self.var_Inter1[2:-2:2]*(Int_sqr+sqr_clap1[2:-2:2]-2*integ_weight*clap1_int[2:-2:2])\
+(sqr_Inter1[2:-2:2]*err_clap1_int[2:-2:2])))+16*N.sum((self.var_Inter1[1:-1:2]*(Int_sqr\
+sqr_clap1[1:-1:2]-2*integ_weight*clap1_int[1:-1:2])+(sqr_Inter1[1:-1:2]*err_clap1_int[1:-1:2])))\
+((self.var_Inter1[-1]*(Int_sqr+sqr_clap1[-1]-2*integ_weight*clap1_int[-1])\
+(sqr_Inter1[-1]*err_clap1_int[-1]))))*(99.940/1001.)**2/(1892.25*9.*Int_sqr**2)
# We have to compute the error on that!!!
return (weight_funct/43.5),weight_funct_err
def beamfrackernel(kernelx, kernely, length, angle):
"""
The beam fraction intercepted by a sample, used for calculating footprints.
Parameters
----------
kernelx: array-like
x axis for the probability kernel
kernely: array-like
probability kernel describing the intensity distribution of the beam
length: float
length of the sample
angle: float
angle of incidence (degrees)
Returns
-------
fraction: float
The fraction of the beam intercepted by a sample.
"""
height_of_sample = length * np.sin(np.radians(angle))
total = integrate.simps(kernely, kernelx)
lowlimit = np.where(-height_of_sample / 2. >= kernelx)[0][-1]
hilimit = np.where(height_of_sample / 2. <= kernelx)[0][0]
area = integrate.simps(kernely[lowlimit: hilimit + 1],
kernelx[lowlimit: hilimit + 1])
return area / total
def print_model_results(model_name, means, sigmas, header=True):
med_mean = np.median(means)
n_data = float(np.size(means))
n_params = likelihood.ndim
model_grids = model_grids(model_name)
likelihood = likelihood(means, sigmas, med_mean, *model_grids[0:6])
posterior, evidence = posterior_evidence(likelihood, *model_grids[6:8])
AIC, AICc, BIC = info_criteria(likelihood, n_data)
marg_post = 1.0*posterior
while marg_post.ndim != 1:
marg_post = integrate.simps(marg_post)
cdf = np.zeros_like(marg_post)
for j in range(1,cdf.size):
cdf[j] = integrate.simps(p_ld[0:j+1],ld[0:j+1])
interp_from_cdf = interp1d(cdf,ld)
cdf_prctls = (int_cdf(0.5), int_cdf(0.84)-int_cdf(0.5), int_cdf(0.5)-int_cdf(0.16))
if header==True:
print 'model (M_k) \t N_free \t P(mu0 | D, M_k) \t log evidence \t AIC \t AICc \t BIC'
print model_name+'\t %1i \t %.2f^{+%.2f}_{-%.2f} \t %.2f \t %.2f \t %.2f \t %.2f' % \
(n_params, interp_from_cdf(0.5), interp_from_cdf(0.84)-interp_from_cdf(0.5),
interp_from_cdf(0.5)-interp_from_cdf(0.16), np.log10(evidence), AIC, AICc, BIC)
return
def cos(x,frequency,phase,amplitude,offset,xlo,xhi,efficiency=None,num_int_points=100,subranges=None):
xnorm = np.linspace(xlo,xhi,num_int_points)
ynorm = offset + amplitude*np.cos(frequency*xnorm + phase)
if efficiency!=None:
ynorm *= efficiency(xnorm)
normalization = integrate.simps(ynorm,x=xnorm)
# Subranges of the normalization.
if subranges!=None:
normalization = 0.0
for sr in subranges:
xnorm = np.linspace(sr[0],sr[1],num_int_points)
#ynorm = np.exp(-slope*xnorm)
ynorm = offset + amplitude*np.cos(frequency*xnorm + phase)
if efficiency!=None:
ynorm *= efficiency(xnorm)
normalization += integrate.simps(ynorm,x=xnorm)
#print "building normalization: ", normalization
#y = np.exp(-slope*x)/normalization
y = offset + amplitude*np.cos(frequency*x + phase)
if efficiency!=None:
y *= efficiency(x)
return y/normalization
def exp(x,slope,xlo,xhi,efficiency=None,num_int_points=100,subranges=None):
xnorm = np.linspace(xlo,xhi,num_int_points)
ynorm = np.exp(-slope*xnorm)
if efficiency!=None:
ynorm *= efficiency(xnorm)
normalization = integrate.simps(ynorm,x=xnorm)
# Subranges of the normalization.
if subranges!=None:
normalization = 0.0
for sr in subranges:
xnorm = np.linspace(sr[0],sr[1],num_int_points)
ynorm = np.exp(-slope*xnorm)
if efficiency!=None:
ynorm *= efficiency(xnorm)
normalization += integrate.simps(ynorm,x=xnorm)
y = np.exp(-slope*x)/normalization
#'''
if efficiency!=None:
y *= efficiency(x)
#'''
return y
def __init__(self, centre, width, steps=200):
"""
:type steps: int
"""
super(TophatFilter, self).__init__()
self.centre = centre * u.angstrom
self.width = width * u.angstrom
self.steps = steps
upper, lower = self.centre + self.width, self.centre - self.width
resp_upper, resp_lower = self.centre + (self.width * 0.5), self.centre - (self.width * 0.5)
self.wave = np.linspace(lower, upper, steps)
self.response = np.zeros_like(self.wave.value)
tophat = (self.wave >= resp_lower) * (self.wave < resp_upper)
self.response[tophat] = 1
self.freq = (c.c / self.wave).to(u.Hz)
self.lambda_c = (simps(self.wave * self.response, self.wave) /
simps(self.response, self.wave))
self.nu_c = (simps(self.freq * self.response, self.freq) /
simps(self.response, self.freq))
self.fwhm = self.width
def calculateViolation(predictLine, allocateline, startTime ,endTime):
stepSize = 1
violateArea = 0
violateTime = 0
area_violations = []
time_violations = []
for i in drange(startTime + stepSize, endTime, stepSize):
predicted_i0 = getValue(predictLine,i - stepSize)
predicted_i1 = getValue(predictLine,i)
##print("Predicty= i0 :%s i1:%s" %(predicted_i0,predicted_i1))
allocated_i0 = getValue(allocateline, i - stepSize)
allocated_i1 = getValue(allocateline,i)
area_under_predicted = simps(y = [predicted_i0, predicted_i1] , dx = stepSize)
area_under_allocated = simps(y = [allocated_i0, allocated_i1] , dx = stepSize)
##print("Areas : %s, %s" %(area_under_predicted,area_under_allocated))
if area_under_allocated < area_under_predicted:
violateArea += (area_under_predicted -area_under_allocated)
violateTime += stepSize
area_violations.append(violateArea)
time_violations.append(violateTime)
area = np.array(area_violations)
time = np.array(time_violations)
xvalue = np.arange(startTime+stepSize, endTime, stepSize)
f , (plt1, plt2) = plt.subplots(1,2, sharex= True)
plt1.plot(xvalue,area)
plt2.plot(xvalue,time)
#plt.show()
#print("ViolateArea : %s ViolateTime : %s" %(violateArea, violateTime))
return violateArea, violateTime
def fit_single_line_BS(self, x, y, zero_lev, err_continuum, fitting_parameters, bootstrap_iterations = 1000):
#Declare parameters and containers for the fit
params_dict = fitting_parameters.valuesdict()
initial_values = [params_dict['A0'], params_dict['mu0'], params_dict['sigma0']]
area_array = empty(bootstrap_iterations)
params_array = empty([3, bootstrap_iterations])
n_points = len(x)
#Perform the fit
for i in range(bootstrap_iterations):
y_new = y + np_normal_dist(0, err_continuum, n_points)
area_array[i] = simps(y_new, x) - simps(zero_lev, x)
best_vals, covar = curve_fit(gaussian_curveBS, (x, zero_lev), y_new, p0=initial_values, maxfev = 1600)
params_array[:,i] = best_vals
#Compute Bootstrap output
mean_area, std_area = mean(area_array), std(area_array)
mean_params_array, stdev_params_array = params_array.mean(1), params_array.std(1)
#Store the data
self.fit_dict['area_intg'], self.fit_dict['area_intg_er'] = mean_area, std_area
self.fit_dict['A0_norm'], self.fit_dict['A0_norm_er'] = mean_params_array[0], stdev_params_array[0]
self.fit_dict['mu0_norm'], self.fit_dict['mu0_norm_er'] = mean_params_array[1], stdev_params_array[1]
self.fit_dict['sigma0_norm'], self.fit_dict['sigma0_norm_er'] = mean_params_array[2], stdev_params_array[2]
A = ufloat(mean_params_array[0], stdev_params_array[0])
sigma = ufloat(mean_params_array[2], stdev_params_array[2])
fwhm0_norm = 2.354820045 * sigma
areaG0_norm = A * sigma * self.sqrt2pi
self.fit_dict['fwhm0_norm'], self.fit_dict['fwhm0_norm_er'] = fwhm0_norm.nominal_value, fwhm0_norm.std_dev
self.fit_dict['area_G0_norm'], self.fit_dict['area_G0_norm_er'] = areaG0_norm.nominal_value, areaG0_norm.std_dev
return
def __init__(self, filepath, maxbins=1000):
"""
:type filepath: string
:type maxbins: int
"""
super(FileFilter, self).__init__()
self.path = filepath
data = np.loadtxt(self.path)
wf = data[:, 0]
tp = data[:, 1]
if len(data[:, 0]) < maxbins: # Re-sample large filters for performance
wfx = np.linspace(wf[0], wf[-1], maxbins)
tpx = griddata(wf, tp, wfx)
wf = wfx
tp = tpx
self.wave = wf * u.angstrom
self.response = tp
self.freq = (c.c / self.wave).to(u.Hz)
nmax = np.argmax(self.response)
halfmax_low = self.wave[:nmax][np.argmin(np.abs(self.response[nmax] - 2 * self.response[:nmax]))]
halfmax_hi = self.wave[nmax:][np.argmin(np.abs(self.response[nmax] - 2 * self.response[nmax:]))]
self.fwhm = halfmax_hi - halfmax_low
self.lambda_c = (simps(self.wave * self.response, self.wave) /
simps(self.response, self.wave)) * u.angstrom
self.nu_c = (simps(self.freq * self.response, self.freq) /
simps(self.response, self.freq)) * u.Hz
def KramersKronig(f, re, im, usezero=False):
"""Return real/imaginary parts retrieved by Kramers-Kronig relations.
formulas including singularity removal according to Boukamp (1993)
"""
from scipy.integrate import simps
x = f * 2. * pi
im2 = np.zeros(im.shape)
re2 = np.zeros(im.shape)
re3 = np.zeros(im.shape)
drdx = np.diff(re) / np.diff(x)
dredx = np.hstack((drdx[0], (drdx[:-1] + drdx[1:]) / 2, drdx[-1]))
didx = np.diff(im) / np.diff(x)
dimdx = np.hstack((didx[0], (didx[:-1] + didx[1:]) / 2, didx[-1]))
for num, w in enumerate(x):
x2w2 = x**2 - w**2
x2w2[num] = 1e-12
fun1 = (re - re[num]) / x2w2
fun1[num] = dredx[num] / 2 / w
im2[num] = -simps(fun1, x) * 2. * w / pi
fun2 = (im * w / x - im[num]) / x2w2
re2[num] = simps(fun2, x) * 2. * w / pi + re[0]
fun3 = (im * x - im[num] * w) / x2w2
fun3[num] = (im[num] / w + dimdx[num]) / 2
re3[num] = simps(fun3, x) * 2. / pi + re[-1]
if usezero:
re3 = re2
return re3, im2
def fit_single_line(self, x, y, zero_lev, err_continuum, fitting_parameters, bootstrap_iterations = 1000):
#Simple fit
if self.fit_dict['MC_iterations'] == 1:
fit_output = lmfit_minimize(residual_gauss, fitting_parameters, args=(x, y, zero_lev, err_continuum))
self.fit_dict['area_intg'] = simps(y, x) - simps(zero_lev, x)
self.fit_dict['area_intg_err'] = 0.0
#Bootstrap
else:
mini_posterior = Minimizer(lnprob_gaussCurve, fitting_parameters, fcn_args = ([x, y, zero_lev, err_continuum]))
fit_output = mini_posterior.emcee(steps=200, params = fitting_parameters)
#Bootstrap for the area of the lines
area_array = empty(bootstrap_iterations)
len_x_array = len(x)
for i in range(bootstrap_iterations):
y_new = y + np_normal_dist(0.0, err_continuum, len_x_array)
area_array[i] = simps(y_new, x) - simps(zero_lev, x)
self.fit_dict['area_intg'] = mean(area_array)
self.fit_dict['area_intg_err'] = std(area_array)
#Store the fitting parameters
output_params = fit_output.params
for key in self.fit_dict['parameters_list']:
self.fit_dict[key + '_norm'] = output_params[key].value
self.fit_dict[key + '_norm_er'] = output_params[key].stderr
return
def int_func(**kwargs):
if iter(list(kwargs.items())) == 1 :
f = kwargs.xin
x = numpy.arrange(numpy.size(f))*1.
else:
f = kwargs.fin
x = kwargs.xin
n = numpy.size(f)
g = numpy.zeros(n)
if kwargs.simple != None :
# Just use trapezium rule
g[0] = 0.0
for i in range (1, n):
g[i] = g[i-1] + 0.5*(x[i] - x[i-1])*(f[i] + f[i-1])
else:
n2 = numpy.int(old_div(n,2))
g[0] = 0.0
for i in range (n2, n) :
g[i] = integrate.simps( f[0:i], x[0:i] )
for i in range (1, n2) :
g[i] = g[n-1] - integrate.simps( f[i:], x[i:] )
return g
def sfq0(rdfX,rdfY,ndens,Lmax=20.0,qbins=1024,damped=None):
minq,maxq,dq=0,Lmax,Lmax/qbins
qs=[i*dq+minq for i in range(qbins)]
qs[0]=1E-10
rdfY=np.array(rdfY)
rdfX=np.array(rdfX)
dx = rdfX[1]-rdfX[0]
#Extend the h(r) to get a better estimate near q0
cr,grExtx,grExty = rdfExtend(rdfX,rdfY,ndens,rmax=50.0,Niter=25,T=1000.0,rm=2.5,eps=-1,damped=0.1)
sf1=list()
for i,q in enumerate(qs):
sf1 += [1 + 4*pi*ndens * integrate.simps((rdfY-1.0)*np.sin(q*rdfX)*rdfX/q ,dx=dx)]
import pylab as pl
sf2=list()
for i,q in enumerate(qs):
sf2 += [1 + 4*pi*ndens * integrate.simps((grExty-1.0)*np.sin(q*grExtx)*grExtx/q ,dx=dx)]
# R=1.0/q
# alpha = np.array([(1-rij/2.0/R)**2 * (1+rij/4.0/R) if rij<2*R else 0 for rij in rdfX])
# sf2 += [1 + 4*pi*ndens * integrate.simps((rdfY-1.0)*np.sin(q*rdfX)*rdfX/q*alpha,dx=dx)]
f=open("/home/acadien/Dropbox/sfq0.dat","w")
a=map(lambda x: "%f %f\n"%(x[0],x[1]),zip(qs,sf2))
f.writelines(a)
# exit(0)
pl.plot(qs,sf1)
pl.plot(qs,sf2)
pl.show()
exit(0)
def get_dband_center(self, d_cols):
"""
Get d-band center of the DosX object.
Parameters:
-----------
d_cols: The column number range for d orbitals, tuple of int.
Examples:
---------
# The 5 - 9 columns are state density for d orbitals.
>>> dos.get_dband_center(d_cols=(5, 10))
"""
# 合并d轨道DOS
start, end = d_cols
yd = np.sum(self.data[:, start:end], axis=1)
#获取feimi能级索引
for idx, E in enumerate(self.data[:, 0]):
if E >= 0:
nfermi = idx
break
E = self.data[: nfermi+1, 0] # negative inf to Fermi
dos = yd[: nfermi+1] # y values from negative inf to Fermi
# Use Simpson integration to get d-electron number
nelectro = simps(dos, E)
# Get total energy of dband
tot_E = simps(E*dos, E)
dband_center = tot_E/nelectro
self.dband_center = dband_center
return dband_center
def int_func( xin, fin=None, simple=None):
if fin is None :
f = copy.deepcopy(xin)
x = numpy.arange(numpy.size(f)).astype(float)
else:
f = copy.deepcopy(fin)
x = copy.deepcopy(xin)
n = numpy.size(f)
g = numpy.zeros(n)
if simple is not None :
# Just use trapezium rule
g[0] = 0.0
for i in range (1, n) :
g[i] = g[i-1] + 0.5*(x[i] - x[i-1])*(f[i] + f[i-1])
else:
n2 = numpy.int(old_div(n,2))
g[0] = 0.0
for i in range (n2, n) :
g[i] = simps( f[0:i+1], x[0:i+1])
for i in range (1, n2) :
g[i] = g[n-1] - simps( f[i::], x[i::])
return g
def radiation_integrals(lattice, twiss_0, nsuperperiod = 1):
#TODO: add I4 for rectangular magnets I4 = Integrate(2 Dx(z)*k(z)*h(z), Z)
n_points_element = 20
tws_elem = twiss_0
(I1, I2, I3,I4, I5) = (0., 0., 0., 0., 0.)
h = 0.
for elem in lattice.sequence:
if elem.__class__ in (SBend, RBend, Bend) and elem.l != 0:
Dx = []
Hinvariant = []
Z = []
h = elem.angle/elem.l
for z in linspace(0, elem.l,num = n_points_element, endpoint=True):
tws_z = elem.transfer_map(z)*tws_elem
Dx.append(tws_z.Dx)
Z.append(z)
Hx = (tws_z.gamma_x*tws_z.Dx*tws_z.Dx + 2.*tws_z.alpha_x*tws_z.Dxp*tws_z.Dx
+ tws_z.beta_x*tws_z.Dxp*tws_z.Dxp)
Hinvariant.append(Hx)
#H = array(h)
H2 = h*h
H3 = abs(h*h*h)
I1 += h*simps(array(Dx), Z)
I2 += H2*elem.l #simps(H2, Z)*nsuperperiod
I3 += H3*elem.l #simps(H3, Z)*nsuperperiod
I4 += h*(2*elem.k1 + H2)*simps(array(Dx), Z)
I5 += H3*simps(array(Hinvariant), Z)
tws_elem = elem.transfer_map*tws_elem
#if abs(tws_elem.beta_x - twiss_0.beta_x)>1e-7 or abs(tws_elem.beta_y - twiss_0.beta_y)>1e-7:
# print( "WARNING! Results may be wrong! radiation_integral() -> beta functions are not matching. ")
#return None
return (I1*nsuperperiod,I2*nsuperperiod,I3*nsuperperiod, I4*nsuperperiod, I5*nsuperperiod)
def nnf(func,normrange=(0,10),data=None,num_int_points=100,verbose=False,subnormranges=None):
xnorm = np.linspace(normrange[0],normrange[1],num_int_points)
# Subranges of the normalization.
normalization = 1.0
if subnormranges!=None:
xnormtot = []
normalization = 0.0
for sr in subnormranges:
xnorm = np.linspace(sr[0],sr[1],num_int_points)
ynorm = func.pdf(xnorm)
normalization += integrate.simps(ynorm,x=xnorm)
xnormtot += xnorm.tolist()
xnorm = np.array(xnormtot)
else:
normalization = integrate.simps(func.pdf(xnorm),x=xnorm)
if verbose:
print("normalization: {0}".format(normalization))
if data is None:
return func.pdf(xnorm)/normalization,xnorm
else:
return func.pdf(data)/normalization,xnorm
def Matsubara(self, iom):
""" evaluate self-energy at matsubara axis
"""
gm = 1/self.a2
(x0, dh0) = swing_make_mesh(500, 1e-5*gm, 300*gm, gm)
F0 = array([self.Fun(x) for x in x0])
F00 = self.Fun(0.0)
weigh0 = abs(self.expan_i[0]) / (pi*F00)
datai=zeros(len(x0),dtype=float)
datar=zeros(len(x0),dtype=float)
F0i=[]
F0r=[]
for n in range(len(iom)):
omn = iom[n]
if (omn<0.3): subtract=1
else: subtract=0
for i in range(len(F0)):
datai[i] = (F0[i]-F00*subtract)/(omn**2+x0[i]**2)
datar[i] = F0[i]*x0[i]/(omn**2+x0[i]**2)
wi = -(omn*integrate.simps(datai, x0) + F00*pi*subtract)
wr = -integrate.simps(datar, x0)
F0i.append(wi)
F0r.append(wr)
return (array(F0r), array(F0i), weigh0)
def filtcheck(self, bandpass, z, frac=0.75, survey="Euclid", f_index=-1):
"""
check if the redshifted effective wavelength is redder than the effective
wavelength of the reddest filter (yes, its a complicated sentence)
Input is a bandpass (as a string) and redshift
"""
bp_rest = sncosmo.get_bandpass(bandpass)
if survey == "Euclid":
effwave = self.effwave_arr
filtarr = self.filtarr
elif survey == "LSST":
effwave = self.lsst_effwave_arr
filtarr = self.lsst_filtarr
if bp_rest.wave_eff*(1+z) > effwave[f_index]:
filtfun=filtarr[effwave==effwave[f_index]][0]
#condition: check what fraction of the redshifted filter is
cond = bp_rest.wave*(1+z) < max(filtfun.wave[filtfun.trans > 1e-4])
simp_prod = simps(bp_rest.trans, bp_rest.wave)
if len(bp_rest.wave[cond])>10:
simp_prod_cond = simps(bp_rest.trans[cond],bp_rest.wave[cond])
else:
simp_prod_cond=0
if simp_prod_cond/simp_prod > frac:
return 1
else:
print "rest-frame filter is too red for observation"
return 0
else:
return 1
def _prob_I(v, x_t):
if v == 1:
if prob_I_cache.has_key(tuple(x_t)):
return prob_I_cache.get(tuple(x_t))
else:
sigma = 4 # todo change this
delta = 2
span = sigma*4
x_range = range(1, span, delta)
k = len(x_range)
matx = np.zeros((k, k))
for i in x_range:
for j in x_range:
i_f = x_t[0] - (span/2) + i
j_f = x_t[1] - (span/2) + j
if (np.array([i_f, j_f]) < 0).any() or (np.array([i_f, j_f]) >= 512).any():
matx[i/delta, j/delta] = 0
else:
matx[i/delta, j/delta] = f([i_f, j_f], x_t, sigma)
first = scint.simps(matx, x_range, axis=0)
_sum = scint.simps(first, x_range)
val = 1-_sum
prob_I_cache[tuple(x_t)] = val
return val
else:
return 0
def __init__(self,filepath,minbins=200):
self.path = filepath
# try:
data = numpy.loadtxt(self.path)
wf = data[:,0]
tp = data[:,1]
if len(data[:,0]) < minbins: #Re-sample large filters for performance
wfx = numpy.linspace(wf[0],wf[-1],minbins)
tpx = griddata(wf,tp,wfx)
wf = wfx
tp = tpx
self.wave = wf * U.angstrom
self.response = tp
self.freq = (C.c/self.wave).to(U.Hz)
nmax = numpy.argmax(self.response)
halfmax_low = self.wave[:nmax][numpy.argmin(numpy.abs(self.response[nmax] - 2*self.response[:nmax]))]
halfmax_hi = self.wave[nmax:][numpy.argmin(numpy.abs(self.response[nmax] - 2*self.response[nmax:]))]
print self.wave[nmax],halfmax_low, halfmax_hi
self.fwhm = halfmax_hi-halfmax_low
self.lambda_c = (simps(self.wave*self.response,self.wave) /
simps(self.response,self.wave))
self.nu_c = (simps(self.freq*self.response,self.freq) /
simps(self.response,self.freq))
def synthesize_photometric_point(filt, wl, fl):
import photometry
'''Takes in a spectrum in [ang], and [erg/(s cm^2 ang)], and then returns Jy'''
if filt in {"u","g","r","i","z"}:
wl_key = "lam"
p_key = "air1.0"
else:
wl_key = "WL"
p_key = "RES"
p = interp1d(photometry.responses[filt][wl_key],photometry.responses[filt][p_key])
filt_re = photometry.responses[filt][wl_key]
p_min = min(filt_re)
p_max = max(filt_re)
if p_min < wl[0] or p_max > wl[-1]:
print("ERROR, spectrum is out of range of filter: %s" % filt)
def px(x):
if (x < p_min) or (x > p_max):
return 0
else:
return p(x)
pxs = map(px, wl)
f_num = wl * pxs * fl
f_denom = wl * pxs
#print f_num, f_denom
num = simps(f_num, x=wl)
denom = simps(f_denom, x=wl)
flux = num/denom
#This should be in spectral flux [erg/(s cm^2 A)]
central = denom/simps(pxs, wl)
#Returned product is in Jy
return photometry.Flamb_to_Jy(flux,central)
def Compute_Delta(niom, T, mu, Sig):
# Matsubara Frequencies
iom = pi*T*(2*arange(niom)+1)
# Load DOS
DOSfile = loadtxt('2D_SL_DOS')
# 1st column as energies
ommesh = DOSfile[:,0]
# 2nd column as DOS
DOS = DOSfile[:,1]
# Normalize
DOS = DOS / integrate.simps(DOS, ommesh)
# Local Green function
Gloc = zeros(niom, dtype=complex)
for i in range(niom):
Re = mu - ommesh - Sig[i].real
Im = iom[i] - Sig[i].imag
denom = 1/(Re**2 + Im**2)
ReInt = DOS*Re*denom
ImInt = DOS*Im*denom
Gloc[i] = integrate.simps(ReInt, ommesh) - 1j*integrate.simps(ImInt, ommesh)
Delta = 1j*iom+mu-Sig-1./Gloc
with open('Delta.inp', 'w') as f:
for i in range(niom):
f.write('%.8f\t%.8f\t%.8f\n'%(iom[i], Delta[i].real, Delta[i].imag))
def process_fid(fid, absint=False):
ft = cut_fft(do_fft(cut_fid(fid)))
if absint:
res = integrate.simps(np.abs(ft['fft']), ft.index)
else:
res = integrate.simps(np.real(ft['fft']), ft.index)
return res
def cosine_content(pca_space, i):
"""Measure the cosine content of the PCA projection.
The cosine content of pca projections can be used as an indicator if a
simulation is converged. Values close to 1 are an indicator that the
simulation isn't converged. For values below 0.7 no statement can be made.
If you use this function please cite [BerkHess1]_.
Parameters
----------
pca_space: array, shape (number of frames, number of components)
The PCA space to be analyzed.
i: int
The index of the pca_component projectection to be analyzed.
Returns
-------
A float reflecting the cosine content of the ith projection in the PCA
space. The output is bounded by 0 and 1, with 1 reflecting an agreement
with cosine while 0 reflects complete disagreement.
References
----------
.. [BerkHess1] Berk Hess. Convergence of sampling in protein simulations.
Phys. Rev. E 65, 031910 (2002).
"""
from scipy.integrate import simps
t = np.arange(len(pca_space))
T = len(pca_space)
cos = np.cos(np.pi * t * (i + 1) / T)
return ((2.0 / T) * (simps(cos*pca_space[:, i])) ** 2 /
simps(pca_space[:, i] ** 2))
def SusceptibilityHF(U,GF_A,X_A): ''' susceptibility calculated from the full spectral self-energy derivative ''' Int1_A = FD_A*sp.imag(GF_A**2*(1.0-U*X_A)) Int2_A = FD_A*sp.imag(GF_A**2*X_A) I1 = simps(Int1_A,En_A)/sp.pi I2 = simps(Int2_A,En_A)/sp.pi return 2.0*I1/(1.0+U**2*I2)
def test_simpson():
ncalls = 10
func = lambda x: np.sin(x - 0.2414)*x + 2.
x = np.linspace(0, 10, 250001)
y = func(x)
t0 = time.time()
for i in range(ncalls):
s1 = simpson(y, dx=x[1]-x[0])
print("cython (odd): {0} sec for {1} calls".format(time.time() - t0,ncalls))
t0 = time.time()
for i in range(ncalls):
s2 = simps(y, x=x)
print("python (odd): {0} sec for {1} calls".format(time.time() - t0,ncalls))
np.testing.assert_allclose(s1, s2)
# -----------------------------------------------------
print()
x = np.linspace(0, 10, 250000)
y = func(x)
t0 = time.time()
for i in range(ncalls):
s1 = simpson(y, dx=x[1]-x[0])
print("cython (even): {0} sec for {1} calls".format(time.time() - t0,ncalls))
t0 = time.time()
for i in range(ncalls):
s2 = simps(y, x=x)
print("python (even): {0} sec for {1} calls".format(time.time() - t0,ncalls))
np.testing.assert_allclose(s1, s2)
def calcQ(lamin0, specin0, mstar=1.0, helium=False, f_nu=False):
'''
Claculate the number of lyman ionizing photons for given spectrum
Input spectrum must be in ergs/s/A!!
Q = int(Lnu/hnu dnu, nu_0, inf)
'''
lamin = np.asarray(lamin0)
specin = np.asarray(specin0)
c = 2.9979e18 #ang/s
h = 6.626e-27 #erg/s
if helium:
lam_0 = 304.0
else:
lam_0 = 911.6
if f_nu:
nu_0 = c/lam_0
inds, = np.where(c/lamin >= nu_0)
hlam, hflu = c/lamin[inds], specin[inds]
nu = hlam[::-1]
f_nu = hflu[::-1]
integrand = f_nu/(h*nu)
Q = simps(integrand, x=nu)
else:
inds, = np.nonzero(lamin <= lam_0)
lam = lamin[inds]
spec = specin[inds]
integrand = lam*spec/(h*c)
Q = simps(integrand, x=lam)*mstar
return Q
def line_integral(self, func, method='sum'):
"""
func = /oint F(x,y) dl
:param func: self - func(X, Y), Union[ndarray, int, float] or function values or 2D spline
:param method: str, ['sum', 'trapz', 'simps']
:return:
"""
import inspect
import numpy as np
from scipy.integrate import trapz, simps, quad
#
dx = np.hstack((0, np.cumsum(self.dists)))
# first evaluate the dimension of coord - self and the function
if self.grid:
raise TypeError(
'The grid is used - currently not possible to calculated the line average value from grid'
)
if self.dim == 1:
if method == 'sum':
x1 = (self.x1[1:] - self.x1[:-1]) / 2
else:
x1 = self.x1
if inspect.isclass(func) or inspect.isfunction(func):
func_val = func(x1)
elif isinstance(func, float) or isinstance(func, int):
func_val = func
elif inspect.ismodule(inspect.getmodule(func)):
func_val = func(x1)
else:
if method == 'sum':
func_val = (func[1:] + func[:-1]) / 2
else:
func_val = func
if method == 'sum':
line_integral = np.sum(func_val * self.dists)
elif method == 'trapz':
line_integral = trapz(func_val, dx)
elif method == 'simps':
line_integral = simps(func_val, dx)
else:
line_integral = None
elif self.dim == 2:
if method == 'sum':
x1 = (self.x1[1:] + self.x1[:-1]) / 2
x2 = (self.x2[1:] + self.x2[:-1]) / 2
else:
x1 = self.x1
x2 = self.x2
if inspect.isclass(func) or inspect.isfunction(func):
func_val = func(x1, x2)
elif isinstance(func, float) or isinstance(func, int):
func_val = func
elif inspect.ismodule(inspect.getmodule(func)):
func_val = func(x1, x2)
else:
if method == 'sum':
if func.ndim == 1:
func_val = (func[1:] + func[:-1]) / 2
else:
func_val = (func[1:, 1:] + func[:-1, :-1]) / 2
else:
func_val = func
if method == 'sum':
line_integral = np.sum(func_val * self.dists)
elif method == 'trapz':
if func_val.ndim == 1:
line_integral = trapz(func_val, dx)
else:
line_integral = trapz(trapz(func_val, x1), x2)
elif method == 'simps':
if func_val.ndim == 1:
line_integral = simps(func_val, dx)
else:
line_integral = simps(simps(func_val, x1), x2)
else:
line_integral = None
elif self.dim == 3:
raise TypeError(
'The 3D function was given - line averaged value needs 2D')
return line_integral
def noise_averaging(x, noise_weights, cj_array):
from scipy.integrate import simps
norm = simps(noise_weights, x)
matrix_int = simps(np.multiply(cj_array, noise_weights), x)
return matrix_int / norm
x_totalrot = np.zeros(num_samples)
y_totalrot = np.zeros(num_samples)
z_totalrot = np.zeros(num_samples)
x_peakvel = np.zeros(num_samples)
y_peakvel = np.zeros(num_samples)
z_peakvel = np.zeros(num_samples)
x_peakrot = np.zeros(num_samples)
y_peakrot = np.zeros(num_samples)
z_peakrot = np.zeros(num_samples)
classlabels = np.zeros(num_samples, dtype=int)
for i in range(num_samples):
x_velocity = cumtrapz(movement_rawdata_collected[i]["x acceleration"][:])
x_peakvel[i] = abs(max(x_velocity, key=abs))
x_totaldisp[i] = simps(x_velocity)
y_velocity = cumtrapz(movement_rawdata_collected[i]["y acceleration"][:])
y_peakvel[i] = abs(max(y_velocity, key=abs))
y_totaldisp[i] = simps(y_velocity)
z_velocity = cumtrapz(movement_rawdata_collected[i]["z acceleration"][:])
z_peakvel[i] = abs(max(z_velocity, key=abs))
z_totaldisp[i] = simps(z_velocity)
x_rot_velocity = cumtrapz(movement_rawdata_collected[i]["x gyroscope"][:])
x_peakrot[i] = abs(max(x_rot_velocity, key=abs))
x_totalrot[i] = simps(x_rot_velocity)
y_rot_velocity = cumtrapz(movement_rawdata_collected[i]["y gyroscope"][:])
y_peakrot[i] = abs(max(y_rot_velocity, key=abs))
y_totalrot[i] = simps(y_rot_velocity)
z_rot_velocity = cumtrapz(movement_rawdata_collected[i]["z gyroscope"][:])
z_peakrot[i] = abs(max(z_rot_velocity, key=abs))
def test_pdf_unity_area(self):
from scipy.integrate import simps
# PDF should integrate to one
assert_almost_equal(
simps(stats.genexpon.pdf(numpy.arange(0, 10, 0.01), 0.5, 0.5, 2.0),
dx=0.01), 1, 1)
def analytical_solution(q0,Nph,aval):
"""Analytical solution driver, returns rI, vI"""
import h5py
import numpy as np
import scipy.integrate as sp
z0, z, xR, t0, H0, dUnit, tUnit, lUnit = get_params('DD0000/data0000')
f = h5py.File('DD0000/data0000.cpu0000','r')
rho_data = f.get('/Grid00000001/Density')
rho = rho_data[0][0][0]*dUnit
del(rho_data)
mp = 1.67262171e-24
# initial nH: no need to scale by a, since a(z0)=1, but we do
# need to accomodate for Helium in analytical soln
# nH0 = rho/mp*0.76
nH0 = rho/mp
# We first set the parameter lamda = chi_{eff} alpha2 cl n_{H,0} t0, where
# chi_{eff} = correction for presence of He atoms [1 -- no correction]
# alpha2 = Hydrogen recombination coefficient [2.6e-13 -- case B]
# cl = the gas clumping factor [1 -- homogeneous medium]
# n_{H,0} = initial Hydrogen number density
# t0 = initial time
alpha2 = 2.52e-13
lamda = alpha2*nH0*t0
# Compute the initial Stromgren radius, rs0 (proper, CGS units)
rs0 = (Nph*3.0/4.0/pi/alpha2/nH0/nH0)**(1.0/3.0) # no rescaling since a(z0)=1
# We have the general formula for y(t):
# y(t) = (lamda/xi)exp(-tau(t)) integral_{1}^{a(t)} [da'
# exp(t(a'))/sqrt(1-2q0 + 2q0(1+z0)/a')] , where
# xi = H0*t0*(1+z0),
# H0 = Hubble constant
# tau(a) = (lamda/xi)*[F(a)-F(1)]/[3(2q0)^2(1+z0)^2/2],
# F(a) = [2(1-2q0) - 2q0(1+z0)/a]*sqrt(1-2q0+2q0(1+z0)/a)
#
# Here, a' is the variable of integration, not the time-derivative of a.
F1 = (2.0*(1.0-2.0*q0) - 2.0*q0*(1.0+z0))*sqrt(1.0-2.0*q0+2.0*q0*(1.0+z0))
xi = H0*t0*(1.0+z0)
# set integration nodes/values (lots)
inodes = 1000001
if (aval == 1.0):
numint = 0.0
else:
a = linspace(1,aval,inodes)
integrand = zeros(inodes, dtype=float)
arat = divide(2.0*q0*(1.0+z0), a)
sqa = sqrt(add(1.0-2.0*q0, arat))
afac = subtract(2*(1-2*q0), arat)
arg1 = subtract(afac*sqa, F1)
arg2 = exp(multiply((lamda/xi)/(6*q0*q0*(1+z0)*(1+z0)), arg1))
integrand = divide(arg2,sqa)
# perform numerical integral via composite Simpson's rule
numint = sp.simps(integrand, a)
tauval = (lamda/xi)*((2*(1-2*q0) - 2*q0*(1+z0)/aval)*sqrt(1-2*q0+2*q0*(1+z0)/aval)-F1)/(6*q0*q0*(1+z0)*(1+z0))
y = lamda/xi*exp(-tauval)*numint;
# extract the current Stromgren radius and velocity
ythird = sign(y)*abs(y)**(1.0/3.0);
rI = ythird/aval # compute ratio rI/rS
vI = (lamda/3)*aval/ythird*ythird*(1.0-y/aval**3);
return [rI, vI]
def _integration1D(m, x, axis_indx):
a = simps(m, x[axis_indx], axis=axis_indx)
return a
def pdf2poe1D(pdf, x):
poe = np.zeros((len(x), ))
for i in range(len(x)):
poe[i] = simps(pdf[i:], x[i:])
return poe
E_ind = np.zeros((Nz, Nt + N_delay))
E_rad = np.zeros((Nz, Nt + N_delay))
E_elec = np.zeros((Nz, Nt + N_delay))
E_elec2 = np.zeros((Nz, Nt + N_delay))
E_elec_total = np.zeros((Nz, Nt + N_delay))
E1 = np.zeros(Nz)
E2 = np.zeros(Nz)
E3 = np.zeros(Nz)
E4 = np.zeros(Nz)
#
#it.quad
for i in range(0, Ntz): #for each time t, integrate over z
E1 = (2 - 3 * ((np.sin(theta))**2)) * Iz[:, i] / (c * R * R)
E_ind[:, i] = (1 / (2 * eps0 * math.pi)) * it.simps(E1, dx=dz)
E2 = ((np.sin(theta))**2) * dIz[:, i] / (c * c * R)
E_rad[:, i] = -(1 / (2 * eps0 * math.pi)) * it.simps(E2, dx=dz)
E3 = Iz[:, i]
E_elec[:, i] = (1 / (2 * eps0 * math.pi)) * it.simps(E3, dx=dz)
E4 = (2 - 3 * ((np.sin(theta))**2)) / (R**3)
E_elec_total[:, i] = (1 / (2 * eps0 * math.pi)) * it.simps(
E4, dx=dz) * it.simps(E3, dx=dt)
#
## for j in range(0,Nz):
## print('stuck',i,j)
## E4=(2-3*((np.sin(theta[j]))**2))/(R[j]*R[j]*R[j])
## E_elec_total[j,i]=(1/(2*eps0*math.pi))*it.simps(E4,dx=dz)
def SimpsonsScipy(x, y, I):
integral = simps(y, x)
e = abs(integral-I)/I
return integral, e
def fitter(n):
#if ( ((float(npix)/float(n))-int(float(npix)/float(n))) == 0):
# print( (float(npix)/float(n)),"%")
i = int(n / side_pix)
j = int(n % side_pix)
i += x_i
j += y_i
#example near center with signal
#i=1105
#j=1061
#print( "i",i,"j",j,"x_i",x_i)
if len(cube.shape) > 3:
signal = cube[0, :, j, i]
else:
signal = cube[:, j, i]
if (DoClip):
signal[np.where(signal < 0)] = 0.
if (signal.max() <= 0):
return [None]
mask = signal > -0.01 * signal.max() ##mask for values too negative.
selected_velocities = velocities[mask]
selected_signal = signal[mask]
Amp_init = selected_signal.max() - selected_signal.mean()
if (Amp_init <= 0):
return [None]
#v0_init = selected_velocities[selected_signal==selected_signal.max()]
v0_init = selected_velocities[np.argmax(
selected_signal
)] # selected_velocities[selected_signal==selected_signal.max()]
sigma_init = 0.1
sigma_max = 30.
## take the error as the rmsnoise far from the line
#noise = signal[(velocities<v0_init-1.) | (velocities>v0_init+1.)]
#rmsnoise = sp.sqrt(sp.mean(noise**2.))
a1_init = Amp_init
mu1_init = v0_init
sigma1_init = sigma_init
maxslope = Amp_init / np.fabs(
(np.max(selected_velocities) - np.min(selected_velocities)))
base_a_init = 0.
base_b_init = 0.
if (dv < 0.):
sys.exit("something is wrong with dv")
limit_a1 = (0., 5. * Amp_init) #Bounds for pars
limit_mu1 = (velocities.min() - 1.0, velocities.max() + 1.0)
limit_sigma1 = (dv / 2., sigma_max)
limit_base_a = (-maxslope, maxslope)
limit_base_b = (0., selected_signal.max())
fallback_error_a1 = limit_a1[1]
fallback_error_mu1 = 100.
fallback_error_sigma1 = 100.
fallback_error_base_a = maxslope
fallback_error_base_b = rmsnoise
if (DGauss):
# velorange=velocities.min()-1.0, velocities.max()+1.0
v0_init2 = v0_init
if (Randomize):
v0_init2 += 3. * dv * (
np.random.random() - 0.5
) # selected_velocities[selected_signal==selected_signal.max()]
a2_init = Amp_init
mu2_init = v0_init2
sigma2_init = sigma_init
limit_a2 = (0., 5. * Amp_init), #Bounds for pars
limit_mu2 = (velocities.min() - 1.0, velocities.max() + 1.0)
limit_sigma2 = (dv / 2., sigma_max)
fallback_error_a2 = limit_a1[1]
fallback_error_mu2 = 100.
fallback_error_sigma2 = 100.
if (CommonSigma):
if DoBaseline:
func = lambda x, a1, mu1, sigma1, a2, mu2, base_a, base_b: dgauss_wbase(
x, a1, mu1, sigma1, a2, mu2, sigma1, base_a, base_b)
p0 = np.array([
a1_init, mu1_init, sigma1_init, a2_init, mu2_init,
base_a_init, base_b_init
])
bounds = (limit_a1, limit_mu1, limit_sigma1, limit_a2,
limit_mu2, limit_base_a, limit_base_b)
fallback_errors = np.array(
(fallback_error_a1, fallback_error_mu1,
fallback_error_sigma1, fallback_error_a2,
fallback_error_mu2, fallback_error_base_a,
fallback_error_base_b))
else:
func = lambda x, a1, mu1, sigma1, a2, mu2: dgauss_wbase(
x, a1, mu1, sigma1, a2, mu2, base_a_init, base_b_init)
p0 = np.array(
[a1_init, mu1_init, sigma1_init, a2_init, mu2_init])
bounds = (limit_a1, limit_mu1, limit_sigma1, limit_a2,
limit_mu2)
fallback_errors = np.array(
(fallback_error_a1, fallback_error_mu1,
fallback_error_sigma1, fallback_error_a2,
fallback_error_mu2))
else:
if DoBaseline:
func = lambda x, a1, mu1, sigma1, a2, mu2, sigma2, base_a, base_b: dgauss_wbase(
x, a1, mu1, sigma1, a2, mu2, sigma2, base_a, base_b)
p0 = np.array([
a1_init, mu1_init, sigma1_init, a2_init, mu2_init,
sigma2_init, base_a_init, base_b_init
])
bounds = (limit_a1, limit_mu1, limit_sigma1, limit_a2,
limit_mu2, limit_sigma2, limit_base_a, limit_base_b)
fallback_errors = np.array(
(fallback_error_a1, fallback_error_mu1,
fallback_error_sigma1, fallback_error_a2,
fallback_error_mu2, fallback_error_sigma2,
fallback_error_base_a, fallback_error_base_b))
else:
func = lambda x, a1, mu1, sigma1, a2, mu2, sigma2: dgauss_wbase(
x, a1, mu1, sigma1, a2, mu2, sigma2, base_a_init,
base_b_init)
p0 = np.array([
a1_init, mu1_init, sigma1_init, a2_init, mu2_init,
sigma2_init
])
bounds = (limit_a1, limit_mu1, limit_sigma1, limit_a2,
limit_mu2, limit_sigma2)
fallback_errors = np.array(
(fallback_error_a1, fallback_error_mu1,
fallback_error_sigma1, fallback_error_a2,
fallback_error_mu2, fallback_error_sigma2))
else:
if DoBaseline:
func = lambda x, a1, mu1, sigma1, base_a, base_b: sgauss_wbase(
x, a1, mu1, sigma1, base_a, base_b)
p0 = np.array(
[a1_init, mu1_init, sigma1_init, base_a_init, base_b_init])
bounds = (limit_a1, limit_mu1, limit_sigma1, limit_base_a,
limit_base_b)
fallback_errors = np.array(
(fallback_error_a1, fallback_error_mu1, fallback_error_sigma1,
fallback_error_base_a, fallback_error_base_b))
else:
func = lambda x, a1, mu1, sigma1: sgauss_wbase(
x, a1, mu1, sigma1, base_a_init, base_b_init)
p0 = np.array([a1_init, mu1_init, sigma1_init])
bounds = (limit_a1, limit_mu1, limit_sigma1)
fallback_errors = np.array(
(fallback_error_a1, fallback_error_mu1, fallback_error_sigma1))
xdata = selected_velocities
ydata = selected_signal
try:
popt, pcov = op.curve_fit(func,
xdata,
ydata,
sigma=np.ones(len(ydata)) * rmsnoise,
p0=p0)
if (np.any(np.diag(pcov) < 0.)):
# print("invalid values in variances",np.diag(pcov))
popt = p0.copy()
perr = fallback_errors
else:
perr = np.sqrt(np.diag(pcov))
except:
#print("Error - curve_fit failed")
popt = p0.copy()
perr = fallback_errors
optimresult = {}
#optimresult['a']={value:popt[0],error:perr[0]}
optimresult['values'] = {}
optimresult['errors'] = {}
#paramnames=['a1','mu1','sigma1','a2','mu2','sigma2','base_a','base_b']
setofparamnames = ['a1', 'mu1',
'sigma1'] #,'a2','mu2','sigma2','base_a','base_b']
for param in enumerate(setofparamnames):
iparam = param[0]
aparam = param[1]
optimresult['values'][aparam] = popt[iparam]
optimresult['errors'][aparam] = perr[iparam]
g_amp = optimresult['values']['a1']
g_v0 = optimresult['values']['mu1']
g_sigma = optimresult['values']['sigma1']
g_amp_e = optimresult['errors']['a1']
g_v0_e = optimresult['errors']['mu1']
g_sigma_e = optimresult['errors']['sigma1']
if (g_sigma < 0):
# print("g_sigma negative: ",g_sigma)
g_sigma = sigma1_init
g_sigma_e = fallback_error_sigma1
gaussfit1 = gaussian(velocities, g_amp, g_v0, g_sigma)
fit1 = gaussfit1
if (DGauss):
pars = popt.copy()
err_pars = perr.copy()
if CommonSigma:
#pars = [optimresult['values']['a'], optimresult['values']['mu'], optimresult['values']['sigma'],optimresult['values']['a2'], optimresult['values']['mu2'], optimresult['values']['sigma']] # pars for best fit
#err_pars = [optimresult['errors']['a'], optimresult['errors']['mu'], optimresult['errors']['sigma'],optimresult['errors']['a2'], optimresult['errors']['mu2'], optimresult['errors']['sigma']] #error in pars
pars = np.append(pars, pars[2])
err_pars = np.append(err_pars, pars[2])
amps = [[pars[0], 0], [pars[3], 3]]
amps_sorted = sorted(amps, key=itemgetter(0))
i_G1 = amps_sorted[-1][1]
i_G2 = amps_sorted[0][1]
g_amp = pars[i_G1]
g_v0 = pars[i_G1 + 1]
g_sigma = pars[i_G1 + 2]
g_amp_e = err_pars[i_G1]
g_v0_e = err_pars[i_G1 + 1]
g_sigma_e = err_pars[i_G1 + 2]
gaussfit1 = gaussian(velocities, g_amp, g_v0, g_sigma)
g2_amp = pars[i_G2]
g2_v0 = pars[i_G2 + 1]
g2_sigma = pars[i_G2 + 2]
g2_amp_e = err_pars[i_G2]
g2_v0_e = err_pars[i_G2 + 1]
g2_sigma_e = err_pars[i_G2 + 2]
gaussfit2 = gaussian(velocities, g2_amp, g2_v0, g2_sigma)
fit1 = gaussfit1 + gaussfit2
vpeak = velocities[np.argmax(fit1)]
ComputeG8 = True
if ComputeG8:
vpeak_init = vpeak
f_vpeak = lambda vmax: neggaussfit(vmax, g_amp, g_v0, g_sigma,
g2_amp, g2_v0, g2_sigma)
#mvpeak = Minuit(f_vpeak, vmax=vpeak_init, #initial guess
# errordef=1, # error
# error_vmax=dv*0.01,
# #limit_vmax=(velocities.min()-1.0, velocities.max()+1.0),
# limit_vmax=(np.min(selected_velocities), np.max(selected_velocities)), #Bounds for pars
# print_level=0,
# )
#mvpeak.migrad()
#
#vpeakMinuit=mvpeak.values['vmax']
res = op.minimize(f_vpeak, vpeak_init)
vpeak = res.x
#print("Scipy optimize",vpeak," Minuit optimize",vpeakMinuit)
if (DoBaseline):
base_a = popt[-2]
base_b = popt[-1]
baseline = base_a * velocities + base_b
fit1 += baseline
fiterror = np.std(fit1 - signal)
#fitinit = gaussian(velocities, Amp_init,v0_init,sigma_init)
#plt.plot(velocities, signal)
#plt.plot(velocities, fit1)
#plt.plot(velocities, fitinit)
#plt.show()
gmom_0 = abs(simps(fit1, velocities))
# print( "vel range:",np.min(velocities),np.max(velocities),"best fit",pars[1])
ic = np.argmin(abs(velocities - g_v0))
if (g_sigma < sigma_init):
Delta_i = sigma_init / dv
else:
Delta_i = g_sigma / dv
nsigrange = 5
i0 = int(ic - nsigrange * Delta_i)
if (i0 < 0):
i0 = 0
i1 = int(ic + nsigrange * Delta_i)
if (i1 > (len(velocities) - 1)):
i1 = (len(velocities) - 1)
j0 = int(ic - nsigrange * Delta_i)
if (j0 < 0):
j0 = 0
j1 = int(ic + nsigrange * Delta_i)
if (j1 > (len(velocities) - 1)):
j1 = (len(velocities) - 1)
#print( "i0",i0,"i1",i1,"j0",j0,"j1",j1)
sign = 1.
if (velocities[1] < velocities[0]):
sign = -1
Smom_0 = sign * simps(signal[i0:i1], velocities[i0:i1])
Smom_1 = simps(signal[i0:i1] * velocities[i0:i1], velocities[i0:i1])
subvelo = velocities[i0:i1]
Smom_8 = subvelo[np.argmax(signal[i0:i1])]
Smax = np.max(signal[i0:i1])
if (abs(Smom_0) > 0):
Smom_1 /= Smom_0
if (Smom_0 > 0):
var = sign * simps(signal[i0:i1] * (velocities[i0:i1] - Smom_1)**2,
velocities[i0:i1])
if (var > 0):
Smom_2 = np.sqrt(var / Smom_0)
else:
Smom_2 = -1E6
else:
Smom_2 = -1E6
else:
Smom_1 = -1E6
Smom_2 = -1E6
sol = [
i, j, gmom_0, g_amp, g_amp_e, g_v0, g_v0_e, g_sigma, g_sigma_e, Smom_0,
Smom_1, Smom_2, Smom_8, fiterror, gaussfit1
]
if DGauss:
sol.extend([
gaussfit2, g2_amp, g2_amp_e, g2_v0, g2_v0_e, g2_sigma, g2_sigma_e,
vpeak
])
if (DoBaseline):
sol.extend([base_a, base_b, baseline])
sol.extend([
Smax,
])
return sol
#!/usr/bin/env python3
# -*- coding: utf-8 -*-#
#
# Author : Bhishan Poudel; Physics Graduate Student, Ohio University
# Date : Tue Mar 14, 2017
# Imports
import numpy as np
from scipy.integrate import simps
col1, col2 = np.genfromtxt("data.txt",
delimiter=None,
usecols=(0, 1),
dtype=None,
unpack=True)
mysum = simps(col1)
print(mysum)
if __name__=="__main__":
"""
Testing idea of Normalization using the example Int_0^beta d(tau) exp(-tau)
"""
beta=1.5
Norm=0.1
print "beta=",beta,"Norm=",Norm
warm=5000
Ns=int(1e6)
Ne=int(8e6)
Nls=arange(Ns,Ne,Ne/5)
res=[]
measure=100
tls=linspace(0,beta,1000)
yls=array([func(tau) for tau in tls])
exact=integrate.simps(yls,tls)
for Nitt in Nls:
Dorder_init=0 ##we start at order 0
N0p,N1p=Sample(Nitt,warm,measure,Dorder_init)
print "Nitt=",Nitt
print "Exact result of the integration is:"
print exact
print
print "Monte carlo sampling is:"
print Norm*N1p/N0p
res.append(Norm*N1p/N0p)
print
print "Direct Monte carlo sampling is:"
print SimpleMC(Nitt)
def variation(x, V, varsol, params, show = False):
"""Calculates the parameters which minimize the energy for a variational
ground state function in 1D.
Input:
x : (array) Indicates the spatial extent of the domain and imposses
Dirichlet boundary conditions at its endpoints
V : (array) Underlying potential which will determine the solution
varsol : (function) Function of variational parameters which will be
used to constrain the solutions.
varsol(x, [a,b,c,...]) where [a,b,c,...] are particular choices
from params
params : (array) A list of tuples which represent a paricular choice of
parameters for the variational solution. An example:
a = np.arange(0, 10, 0.1)
b = np.arange(0, 10, 0.1)
c = np.arange(0, 10, 0.1)
params = [[i, j, k] for i in a for j in b for k in c]
Output:
psi : (array) The wave function which minimizes the energy on the
domain x for the parameters dictated in params
E : (float) The resulting energy
opt_params : (tuple) List of the parameter values which minimize the
energy
Optional:
show = False : Plots x vs psi, the variational solution and prints the
energy and optimal parameters
Notes:
"""
import numpy as np
from matplotlib import pyplot as plt
from scipy.integrate import simps
#Check that the array x and V are compatible
if len(x) != len(V):
print('Error: x and V are incompatible arrays.')
return 0
#Calculate all of the energies for the input parameter space.
energies = [Evar(x, varsol(x, p)/np.sqrt(simps(varsol(x, p)**2, x)), V)
for p in params]
#Determine the minimum energy
arg_opt_params = np.argmin(energies)
varsol_opt = (varsol(x, params[arg_opt_params]) /
np.sqrt(simps(varsol(x, params[arg_opt_params])**2, x)) )
if show == True:
print('Energy minimum = '+str(energies[arg_opt_params]))
print('Optimum parameters = '+str(params[arg_opt_params]))
fig = plt.figure()
plt.plot(x, varsol_opt, label = 'var sol')
plt.legend()
plt.show()
#Warning if the minimum energy solution is on the edge of the allowed
# parameter space, indicating the a local minimum was never achieved.
#NEED
return varsol_opt, energies[arg_opt_params], params[arg_opt_params]
dat = procdata(galdata,gwdata)
if np.isscalar(hub_arr):
if ii==0:
val = prob_h0(msk_gal_dat,hub_arr)
val = val/(np.sum(val))
else:
val = val * prob_h0(galdata,gwdata,hub_arr)
val = val/(np.sum(val))
else:
val = 0.0*hub_arr
for pp,hh in enumerate(hub_arr):
if ii==0:
val[pp] = prob_h0(dat,hh)
#val = val/(np.sum(val))
else:
val[pp] = val[pp] * prob_h0(dat,hh)
val = val/(1.0*simps(val,hub_arr))
#val = val/(np.sum(val))
print ii
mat = np.transpose([hub_arr,val])
np.savetxt('./post_hub_2.dat',mat,header='#h0,p(h0)')
g4 = np.argmax(np.abs(w1f + q1f))
norm_1f = w1f[g4] + q1f[g4]
w1f /= norm_1f
q1f /= norm_1f
ux /= norm_1f
uy /= norm_1f
uz /= norm_1f
dw1f = np.gradient(w1f, z_1f)
dux = np.gradient(ux, z_1f)
duy = np.gradient(uy, z_1f)
duz = np.gradient(uz, z_1f)
e1f_tot = simps(
rho1f * (np.abs(ux)**2 + 4 * np.abs(uy)**2 + np.abs(uz)**2), z_1f)
e1f_A1 = simps(-(dvx1f * np.real(uz * np.conj(ux))) * rho1f, z_1f)
e1f_A2 = simps(-(4.0 * dvy1f * np.real(uz * np.conj(uy))) * rho1f, z_1f)
e1f_A3 = simps(-(dvz1f * np.abs(uz)**2) * rho1f, z_1f)
e1f_A = e1f_A1 + e1f_A2 + e1f_A3
e1f_B = simps(
-vz1f * np.real(dux * np.conj(ux) + 4.0 * duy * np.conj(uy) +
duz * np.conj(uz)) * rho1f, z_1f)
e1f_C = simps(
(kx1f * np.imag(w1f * np.conj(ux)) - np.real(dw1f * np.conj(uz))) /
(1.0 + eps1f) * rho1f, z_1f)
e1f_D = simps(
-2.0 * eta_hat * np.real(q1f * np.conj(ux)) * eps1f / (1.0 + eps1f) /
(1.0 + eps1f) * rho1f, z_1f)
e1f_E = simps(
sigmaPrior = 1.7 / np.sqrt(2.0)
priorLogN = np.exp(-(np.log(B) - np.log(B0))**2 / (2.0 * sigmaPrior**2)) / B
prior = priorLogN
pl.close('all')
f, ax = pl.subplots(1, 2, figsize=(12, 4), num=1)
ax = ax.flatten()
colors = brewer2mpl.get_map('Dark2', 'qualitative', nFluxes).mpl_colors
loop = 0
for i in range(len(fluxes)):
posterior = prior * pB[2, i, :]
normaliz = simps(posterior, B)
ax[loop].plot(B,
posterior / normaliz,
label=labels[i],
linewidth=2,
color=colors[i])
MMAP[2, i] = B[posterior.argmax()]
ax[loop].set_ylabel(r'p(B|$\Phi_\mathrm{obs}$)')
ax[loop].set_xlabel('B [G]')
#ax[loop].annotate(r'$\sigma_n$='+"{0:4.1f}".format(sigmas[2])+r' Mx cm$^{-2}$', xy=(0.55, 0.86), xycoords='axes fraction', fontsize=14)
ax[loop].set_xlim((0, 400))
ax[loop].legend(labelspacing=0.2, prop={'size': 12}, loc='upper right')
loop += 1
for i in range(len(fluxes)):
posterior = prior * pB[2, i, :]
import numpy as np from scipy.integrate import simps h = (0.5 - 0.1)/2 eps = 0.1 #m, segunda derivada #e = trap = np.trapz([1.8,2.6,3.0,2.8,1.9], x = [0.1,0.2,0.3,0.4,0.5]) sim = simps(np.array([1.8,2.6,3.0,2.8,1.9]), x = [0.1,0.2,0.3,0.4,0.5]) print "metodo de simpson" print sim print "metodo del trapecio" print trap
normed_mean = np.ascontiguousarray(mq[:,r] / np.linalg.norm(mq[:,r]))
for k in range(N):
q_c = q[:,k] / np.linalg.norm(q[:,k])
G,T = dp(normed_mean, t, q_c, t, t, t, lam)
gam0 = np.interp(t, T, G)
gam[k,:] = (gam0-gam0[0])/(gam0[-1] - gam0[0]) # slight change on scale
gam_dev[k,:] = np.gradient(gam[k,:], 1/(M-1))
f_temp[:,k] = np.interp(compose_temp(gam[k,:]), t, f[:,k]);
q_temp[:,k] = np.gradient(f_temp[:,k], binsize) / \
np.sqrt(np.abs(np.gradient(f_temp[:,k], binsize))+eps)
qcollect[:,:,r+1] = q_temp
fcollect[:,:,r+1] = f_temp
ds[r+1] = np.sum(simps(
(mq[:,r].reshape(-1,1) - qcollect[:,:,r+1])**2, t, axis=0)) + \
lam * np.sum(simps((1-np.sqrt(gam_dev.T))**2,t,axis=0))
# Minimization Step
# compute the mean of the matched function
mq[:,r+1] = np.mean(qcollect[:,:,r+1], 1)
qun[r] = np.linalg.norm(mq[:,r+1] - mq[:,r]) / np.linalg.norm(mq[:,r])
if qun[r] < 1e-2 or r >= MaxItr:
break
r = r+1
for k in range(N):
q_c = q[:,k]
mq_c = mq[:,r]
print ' norm0 =', norm
print ' bdims =', mps.bdim()
mps.mul(1.0 / norm)
rfun, wfun = self.quadfun(case, refdet)
from scipy.integrate import trapz, simps
psum = 0.0
expval = 0.0
# Partilce number
if case == 'n':
b = 2 * numpy.pi
xdata = numpy.linspace(0, b, num=npoints)
ydata = fx(xdata, mps, rfun)
for n in range(2 * k + 1):
ydata2 = map(lambda x: wfun(x, n), xdata)
ydata2 = (ydata2 * ydata).real
y = simps(ydata2, xdata)
psum += y
expval += y * n
print ' n =%3d' % n, ' p[n] =%10.5f' % y
elif case == 'sz':
b = 2 * numpy.pi
xdata = numpy.linspace(0, b, num=npoints)
ydata = fx(xdata, mps, rfun)
for sz in numpy.arange(-0.5 * k, 0.5 * k + 0.1, 0.5):
ydata2 = map(lambda x: wfun(x, sz), xdata)
ydata2 = (ydata2 * ydata).real
y = simps(ydata2, xdata)
psum += y
expval += y * sz
print ' sz =%5.1f' % sz, ' p[n] =%10.5f' % y
def calc_beam_area(beam_profile):
r, b = beam_profile
return integrate.simps(2 * np.pi * r * b, r)
# Plot the power spectral density and fill the delta area
plt.figure(figsize=(7, 4))
plt.plot(freqs, psd, lw=2, color='k')
plt.fill_between(freqs, psd, where=idx_delta, color='skyblue')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Power spectral density (uV^2 / Hz)')
plt.xlim([0, 50])
plt.ylim([0, psd.max() * 1.1])
plt.title("Welch's periodogram")
sns.despine()
# Frequency resolution
freq_res = freqs[1] - freqs[0] # = 1 / 4 = 0.25
# Compute the absolute power by approximating the area under the curve
delta_power = simps(psd[idx_delta], dx=freq_res)
print('Absolute delta power: %.3f uV^2' % delta_power)
# Relative delta power (expressed as a percentage of total power)
total_power = simps(psd, dx=freq_res)
delta_rel_power = delta_power / total_power
print('Relative delta power: %.3f' % delta_rel_power)
# 생체 데이터 BandPower 값 구하기
window_sec = 5 * sfreq
delta = [0.2, 4]
theta = [4, 8]
alpha = [8, 12]
beta = [12, 30]
gamma = [30, 100]
def analyze_fast(self, refdet):
print '\n[mps_class.analyze_fast]'
print ' Analyze particle-holes contributions by projection, spin-orbital is assumed.'
print ' refdet = ', refdet
print ' bdims = ', self.bdim()
#
# The population of states with t[ph] 'quantum' number:
# nt = <t|t> where |t>=P|0>
# = <0|P2|0> = <0|P|0> = (numerical integrations)
# Possible values for no. of quasi-particles = [0,K]
# Since the projector itself is Hermitian, nt is real.
#
# U(1) group projector: Pn = 1/2pi*int_{0,2pi} exp(i*(N-n)x) dx
# discretized version: = 1/2pi*sum_{k} exp(-in*xk)*<MPS|MPO(xk)|MPS>
#
global icounter
icounter = 0
# Complex algebra is mandatory in order to use the separability of exp(iNx)
def fx(xdata, mps, refdet):
global icounter
icounter += 1
nsite = len(refdet)
sites1 = mps.torank2()
ydata = numpy.zeros(xdata.shape, dtype=numpy.complex_)
for i, x in enumerate(xdata):
sites2 = []
for isite in range(nsite):
if refdet[isite] == 0:
ntmp = numpy.array([[1., 0.], [0.,
cmath.exp(1.j * x)]])
else:
ntmp = numpy.array([[cmath.exp(1.j * x), 0.], [0.,
1.]])
if isite == 0:
tmp = numpy.einsum('ij,ja->ia', ntmp, sites1[isite])
elif isite == nsite - 1:
tmp = numpy.einsum('ij,aj->ai', ntmp, sites1[isite])
else:
tmp = numpy.einsum('ij,ajb->aib', ntmp, sites1[isite])
sites2.append(tmp)
ydata[i] = mpslib.mps_dot(sites1, sites2) / (2.0 * numpy.pi)
return ydata
# First normalize and compress to accelerate the analysis
norm = self.norm()
mps = self.copy()
#mps.icompress()
print ' norm0 = ', norm
print ' bdims = ', mps.bdim()
mps.mul(1.0 / norm)
norm2 = mps.norm()
k = self.nsite
nelec = sum(refdet)
maxNoQuasiParticles = 2 * (min(nelec, k - nelec) + 1)
from scipy.integrate import trapz, simps
# Trapezoidal rule
npoints = 1000
xdata = numpy.linspace(0, 2 * numpy.pi, num=npoints)
ydata = fx(xdata, mps, refdet)
psum = 0.0
for n in range(maxNoQuasiParticles):
if n % 2 == 1: continue
ydata2 = map(lambda x: cmath.exp(-1.j * n * x), xdata)
ydata2 = (ydata2 * ydata).real
y = simps(ydata2, xdata)
print ' n = %3d' % n, ' erank=', n / 2, ' y=', y, ' icounter=', icounter
psum += y
print ' Total population =', psum
return 0
'''
integ = simps(spectr / k, x=k)
L = 2 * np.pi * integ / E_tot
return L
L_iso = np.zeros(len(tiempo))
L_para = np.zeros(len(tiempo))
L_perp = np.zeros(len(tiempo))
for i in range(2, len(tiempo) + 1):
E_iso = np.loadtxt(path + file_iso.format(i),
delimiter=' ',
usecols=(1, ))
E_tot = simps(E_iso, x=k_iso)
E_para = np.loadtxt(path + file_para.format(i),
delimiter=' ',
usecols=(1, ))
E_perp = np.loadtxt(path + file_perp.format(i),
delimiter=' ',
usecols=(1, ))
L_iso[i - 1] = long_int(k_iso, E_iso, E_tot)
L_para[i - 1] = long_int(k_para[1:], E_para[1:], E_tot)
L_perp[i - 1] = long_int(k_perp[1:], E_perp[1:], E_tot)
#%% Graficamos esto
plt.figure()
def __init__(self, iplot=False, quiet=False):
"""
:param iplot: display the result when set to True (default False)
:type iplot: bool
:param quiet: less verbose when set to True (default is False)
:type quiet: bool
"""
if os.path.exists('tInitAvg'):
file = open('tInitAvg', 'r')
tstart = float(file.readline())
file.close()
logFiles = scanDir('log.*')
tags = []
for lg in logFiles:
nml = MagicSetup(quiet=True, nml=lg)
if nml.start_time > tstart:
if os.path.exists('bLayersR.{}'.format(nml.tag)):
tags.append(nml.tag)
if len(tags) > 0:
print(tags)
else:
tags = None
MagicSetup.__init__(self, quiet=True, nml=logFiles[-1])
a = AvgField()
self.nuss = a.nuss
self.reynolds = a.reynolds
e2fluct = a.ekin_pol_avg + a.ekin_tor_avg - a.ekin_pola_avg - a.ekin_tora_avg
else:
logFiles = scanDir('log.*')
MagicSetup.__init__(self, quiet=True, nml=logFiles[-1])
tags = None
self.nuss = 1.
self.reynolds = 1.
e2fluct = 1.
par = MagicRadial(field='bLayersR', iplot=False, tags=tags)
self.varS = abs(par.entropy_SD)
self.ss = par.entropy
if os.path.exists('tInitAvg'):
logFiles = scanDir('log.*', tfix=1409827718.0)
# Workaround for code mistake before this time
tfix = 1409827718.0
tagsFix = []
for lg in logFiles:
nml = MagicSetup(quiet=True, nml=lg)
if nml.start_time > tstart:
if os.path.exists('bLayersR.{}'.format(nml.tag)):
tagsFix.append(nml.tag)
if len(tagsFix) > 0:
print('Fix temp. tags', tagsFix)
parFix = MagicRadial(field='bLayersR',
iplot=False,
tags=tagsFix)
self.varS = abs(parFix.entropy_SD)
self.ss = parFix.entropy
self.tags = tagsFix
self.uh = par.uh
self.duh = par.duhdr
self.rad = par.radius
self.ro = self.rad[0]
self.ri = self.rad[-1]
vol_oc = 4. / 3. * np.pi * (self.ro**3 - self.ri**3)
self.rey_fluct = np.sqrt(2. * e2fluct / vol_oc)
self.reh = 4. * np.pi * intcheb(self.rad**2 * self.uh,
len(self.rad) - 1, self.ri,
self.ro) / (4. / 3. * np.pi *
(self.ro**3 - self.ri**3))
# Thermal dissipation boundary layer
if hasattr(par, 'dissS'):
self.dissS = par.dissS
self.epsT = -4. * np.pi * intcheb(self.rad**2 * self.dissS,
len(self.rad) - 1, self.ro,
self.ri)
self.epsTR = 4. * np.pi * self.rad**2 * self.dissS
ind = getMaxima(-abs(self.epsTR - self.epsT))
try:
self.dissTopS = self.ro - self.rad[ind[0]]
self.dissBotS = self.rad[ind[-1]] - self.ri
self.dissEpsTbl, self.dissEpsTbulk = integBulkBc(
self.rad, self.epsTR, self.ri, self.ro, self.dissBotS,
self.dissTopS)
except IndexError:
self.dissTopS = self.ro
self.dissBotS = self.ri
self.dissEpsTbl, self.dissEpsTbulk = 0., 0.
print('thDiss bl, bulk', self.dissEpsTbl / self.epsT,
self.dissEpsTbulk / self.epsT)
# First way of defining the thermal boundary layers: with var(S)
#rThLayer = getMaxima(self.rad, self.varS)
ind = argrelextrema(self.varS, np.greater)[0]
if len(ind) != 0:
self.bcTopVarS = self.ro - self.rad[ind[0]]
self.bcBotVarS = self.rad[ind[-1]] - self.ri
else:
self.bcTopVarS = 1.
self.bcBotVarS = 1.
if hasattr(self, 'epsT'):
self.varSEpsTbl, self.varSEpsTbulk = integBulkBc(
self.rad, self.epsTR, self.ri, self.ro, self.bcBotVarS,
self.bcTopVarS)
print('var(S) bl, bulk', self.varSEpsTbl / self.epsT,
self.varSEpsTbulk / self.epsT)
# Second way of defining the thermal boundary layers: intersection of the slopes
d1 = matder(len(self.rad) - 1, self.ro, self.ri)
self.ttm = 3.*intcheb(self.ss*self.rad**2, len(self.rad)-1, self.ri, self.ro) \
/(self.ro**3-self.ri**3)
dsdr = np.dot(d1, self.ss)
self.beta = dsdr[len(dsdr) / 2]
print('beta={:.2f}'.format(self.beta))
self.slopeTop = dsdr[2] * (self.rad - self.ro) + self.ss[0]
self.slopeBot = dsdr[-1] * (self.rad - self.ri) + self.ss[-1]
self.dtdrm = dsdr[len(self.ss) / 2]
tmid = self.ss[len(self.ss) / 2]
self.slopeMid = self.dtdrm * (self.rad -
self.rad[len(self.rad) / 2]) + tmid
self.bcTopSlope = (tmid - self.ss[0]) / (self.dtdrm - dsdr[2])
self.bcBotSlope = -(tmid - self.ss[-1]) / (self.dtdrm - dsdr[-1])
# 2nd round with a more accurate slope
bSlope = dsdr[self.rad <= self.ri + self.bcBotSlope / 4.].mean()
tSlope = dsdr[self.rad >= self.ro - self.bcTopSlope / 4.].mean()
self.slopeBot = bSlope * (self.rad - self.ri) + self.ss[-1]
self.slopeTop = tSlope * (self.rad - self.ro) + self.ss[0]
#self.bcTopSlope = -(self.ttm-self.ss[0])/tSlope
self.bcTopSlope = -(tmid - self.dtdrm * self.rad[len(self.rad) / 2] -
self.ss[0] + tSlope * self.ro) / (self.dtdrm -
tSlope)
self.bcBotSlope = -(tmid - self.dtdrm * self.rad[len(self.rad) / 2] -
self.ss[-1] + bSlope * self.ri) / (self.dtdrm -
bSlope)
self.dto = tSlope * (self.bcTopSlope - self.ro) + self.ss[0]
self.dti = bSlope * (self.bcBotSlope - self.ri) + self.ss[-1]
self.dto = self.dto - self.ss[0]
self.dti = self.ss[-1] - self.dti
self.bcTopSlope = self.ro - self.bcTopSlope
self.bcBotSlope = self.bcBotSlope - self.ri
if hasattr(self, 'epsT'):
self.slopeEpsTbl, self.slopeEpsTbulk = integBulkBc(
self.rad, self.epsTR, self.ri, self.ro, self.bcBotSlope,
self.bcTopSlope)
print('slopes bl, bulk', self.slopeEpsTbl / self.epsT,
self.slopeEpsTbulk / self.epsT)
pow = MagicRadial(field='powerR', iplot=False, tags=tags)
self.vi = pow.viscDiss
self.buo = pow.buoPower
self.epsV = -intcheb(self.vi, len(self.rad) - 1, self.ro, self.ri)
ind = getMaxima(-abs(self.vi - self.epsV))
if len(ind) > 2:
for i in ind:
if self.vi[i - 1] - self.epsV > 0 and self.vi[
i + 1] - self.epsV < 0:
self.dissTopV = self.ro - self.rad[i]
elif self.vi[i - 1] - self.epsV < 0 and self.vi[
i + 1] - self.epsV > 0:
self.dissBotV = self.rad[i] - self.ri
else:
self.dissTopV = self.ro - self.rad[ind[0]]
self.dissBotV = self.rad[ind[-1]] - self.ri
try:
self.dissEpsVbl, self.dissEpsVbulk = integBulkBc(
self.rad, self.vi, self.ri, self.ro, self.dissBotV,
self.dissTopV)
except AttributeError:
self.dissTopV = 0.
self.dissBotV = 0.
self.dissEpsVbl = 0.
self.dissEpsVbulk = 0.
print('visc Diss bl, bulk', self.dissEpsVbl / self.epsV,
self.dissEpsVbulk / self.epsV)
# First way of defining the viscous boundary layers: with duhdr
#rViscousLayer = getMaxima(self.rad, self.duh)
if self.kbotv == 1 and self.ktopv == 1:
ind = argrelextrema(self.duh, np.greater)[0]
if len(ind) == 0:
self.bcTopduh = 1.
self.bcBotduh = 1.
else:
if ind[0] < 4:
self.bcTopduh = self.ro - self.rad[ind[1]]
else:
self.bcTopduh = self.ro - self.rad[ind[0]]
if len(self.rad) - ind[-1] < 4:
self.bcBotduh = self.rad[ind[-2]] - self.ri
else:
self.bcBotduh = self.rad[ind[-1]] - self.ri
self.slopeTopU = 0.
self.slopeBotU = 0.
self.uhTopSlope = 0.
self.uhBotSlope = 0.
self.slopeEpsUbl = 0.
self.slopeEpsUbulk = 0.
self.uhBot = 0.
self.uhTop = 0.
else:
ind = argrelextrema(self.uh, np.greater)[0]
if len(ind) == 1:
ind = argrelextrema(self.uh, np.greater_equal)[0]
if len(ind) == 0:
self.bcTopduh = 1.
self.bcBotduh = 1.
else:
if ind[0] < 4:
self.bcTopduh = self.ro - self.rad[ind[1]]
else:
self.bcTopduh = self.ro - self.rad[ind[0]]
if len(self.rad) - ind[-1] < 4:
self.bcBotduh = self.rad[ind[-2]] - self.ri
else:
self.bcBotduh = self.rad[ind[-1]] - self.ri
self.uhTop = self.uh[self.rad == self.ro - self.bcTopduh][0]
self.uhBot = self.uh[self.rad == self.ri + self.bcBotduh][0]
self.bcBotduh, self.bcTopduh, self.uhBot, self.uhTop = \
getAccuratePeaks(self.rad, self.uh, self.uhTop, \
self.uhBot, self.ri, self.ro)
duhdr = np.dot(d1, self.uh)
#1st round
mask = (self.rad >= self.ro - self.bcTopduh / 4) * (self.rad <
self.ro)
slopeT = duhdr[mask].mean()
mask = (self.rad <= self.ri + self.bcBotduh / 4) * (self.rad >
self.ri)
slopeB = duhdr[mask].mean()
self.slopeTopU = slopeT * (self.rad - self.ro) + self.uh[0]
self.slopeBotU = slopeB * (self.rad - self.ri) + self.uh[-1]
self.uhTopSlope = -self.uhTop / slopeT
self.uhBotSlope = self.uhBot / slopeB
#2nd round
mask = (self.rad >= self.ro - self.uhTopSlope / 4.) * (self.rad <
self.ro)
slopeT = duhdr[mask].mean()
mask = (self.rad <= self.ri + self.uhBotSlope / 4) * (self.rad >
self.ri)
slopeB = duhdr[mask].mean()
self.uhTopSlope = -self.uhTop / slopeT
self.uhBotSlope = self.uhBot / slopeB
self.slopeEpsUbl, self.slopeEpsUbulk = integBulkBc(
self.rad, self.vi, self.ri, self.ro, self.uhBotSlope,
self.uhTopSlope)
self.uhEpsVbl, self.uhEpsVbulk = integBulkBc(self.rad, self.vi,
self.ri, self.ro,
self.bcBotduh,
self.bcTopduh)
print('uh bl, bulk', self.uhEpsVbl / self.epsV,
self.uhEpsVbulk / self.epsV)
# Convective Rol in the thermal boundary Layer
par = MagicRadial(field='parR', iplot=False, tags=tags)
kin = MagicRadial(field='eKinR', iplot=False, tags=tags)
ekinNas = kin.ekin_pol + kin.ekin_tor - kin.ekin_pol_axi - kin.ekin_tor_axi
ReR = np.sqrt(2. * abs(ekinNas) / par.radius**2 / (4. * np.pi))
RolC = ReR * par.ek / par.dlVc
self.dl = par.dlVc
y = RolC[par.radius >= self.ro - self.bcTopSlope]
x = par.radius[par.radius >= self.ro - self.bcTopSlope]
try:
self.rolTop = simps(3. * y * x**2,
x) / (self.ro**3 -
(self.ro - self.bcTopSlope)**3)
except IndexError:
self.rolTop = 0.
self.rolbl, self.rolbulk = integBulkBc(self.rad,
4. * np.pi * RolC * self.rad**2,
self.ri,
self.ro,
self.bcBotSlope,
self.bcTopSlope,
normed=True)
self.rebl, self.rebulk = integBulkBc(self.rad,
4. * np.pi * ReR * self.rad**2,
self.ri,
self.ro,
self.bcBotSlope,
self.bcTopSlope,
normed=True)
self.lengthbl, self.lengthbulk = integBulkBc(self.rad,
self.dl * 4. * np.pi *
self.rad**2,
self.ri,
self.ro,
self.bcBotSlope,
self.bcTopSlope,
normed=True)
self.rehbl, self.rehbulk = integBulkBc(self.rad,
self.uh * 4. * np.pi *
self.rad**2,
self.ri,
self.ro,
self.bcBotduh,
self.bcTopduh,
normed=True)
y = RolC[par.radius <= self.ri + self.bcBotSlope]
x = par.radius[par.radius <= self.ri + self.bcBotSlope]
self.rolBot = simps(3. * y * x**2, x) / (
(self.ri + self.bcBotSlope)**3 - self.ri**3)
print('reynols bc, reynolds bulk', self.rebl, self.rebulk)
print('reh bc, reh bulk', self.rehbl, self.rehbulk)
print('rolbc, rolbulk, roltop, rolbot', self.rolbl, self.rolbulk,
self.rolBot, self.rolTop)
par.dlVc[0] = 0.
par.dlVc[-1] = 0.
self.lBot, self.lTop = integBotTop(self.rad,
4. * np.pi * self.rad**2 * par.dlVc,
self.ri,
self.ro,
self.bcBotSlope,
self.bcTopSlope,
normed=True)
uhbm, utbm = integBotTop(self.rad,
4. * np.pi * self.uh,
self.ri,
self.ro,
self.bcBotSlope,
self.bcTopSlope,
normed=True)
# Convective Rol in the thermal boundary Layer
if len(scanDir('perpParR.*')) != 0:
tags = []
for lg in logFiles:
nml = MagicSetup(quiet=True, nml=lg)
if nml.start_time > tstart:
if os.path.exists('perpParR.{}'.format(nml.tag)):
tags.append(nml.tag)
perpPar = MagicRadial(field='perpParR', iplot=False, tags=tags)
eperpNas = perpPar.Eperp - perpPar.Eperp_axi
eparNas = perpPar.Epar - perpPar.Epar_axi
RePerpNas = np.sqrt(2. * abs(eperpNas))
ReParNas = np.sqrt(2. * abs(eparNas))
RePerp = np.sqrt(2. * abs(perpPar.Eperp))
RePar = np.sqrt(2. * abs(perpPar.Epar))
self.reperpbl, self.reperpbulk = integBulkBc(self.rad,
4. * np.pi * RePerp *
self.rad**2,
self.ri,
self.ro,
self.bcBotSlope,
self.bcTopSlope,
normed=True)
self.reparbl, self.reparbulk = integBulkBc(self.rad,
4. * np.pi * RePar *
self.rad**2,
self.ri,
self.ro,
self.bcBotSlope,
self.bcTopSlope,
normed=True)
self.reperpnasbl, self.reperpnasbulk = integBulkBc(
self.rad,
4. * np.pi * RePerpNas * self.rad**2,
self.ri,
self.ro,
self.bcBotSlope,
self.bcTopSlope,
normed=True)
self.reparnasbl, self.reparnasbulk = integBulkBc(
self.rad,
4. * np.pi * ReParNas * self.rad**2,
self.ri,
self.ro,
self.bcBotSlope,
self.bcTopSlope,
normed=True)
else:
self.reperpbl = 0.
self.reperpbulk = 0.
self.reparbl = 0.
self.reparbulk = 0.
self.reperpnasbl = 0.
self.reperpnasbulk = 0.
self.reparnasbl = 0.
self.reparnasbulk = 0.
if iplot:
self.plot()
if not quiet:
print(self)
momentxz = pd.read_csv("momentxz.csv")
momentxy = pd.read_csv("momentxy.csv")
y_1 = []
x_1 = []
for i in range(0, len(momentxz.index)):
if i < len(momentxz.index) - 1:
a = momentxz.values[i, 1]
b = momentxz.values[i + 1, 1]
c = momentxz.values[i, 0]
d = momentxz.values[i + 1, 0]
fy = [a, b]
fx = [c, d]
dx = (c + d) / 2
first_int = integrate.simps(fy)
y_1.append(first_int)
x_1.append(dx)
y_deflections = []
x_coordinates = []
#1349
y_1[1349] = 0
for i in range(0, len(y_1)):
if i < len(y_1) - 1:
a = y_1[i]
b = y_1[i + 1]
c = x_1[i]
d = x_1[i + 1]
def build(self,
age,
sfh,
dust,
metal,
fesc=1.,
sfh_law='exp',
dustmodel='calzetti',
neb_cont=True,
neb_met=True):
"""
"""
self.tg = age * 1.e9
if sfh_law == 'exp':
self.tau = sfh * 1.e9
elif sfh_law == 'del':
self.tau = sfh * 1.e9
else:
self.tau = sfh
self.tauv = dust
self.mi = int(abs(metal))
self.fesc = fesc
self.sfh_law = sfh_law
self.inc_cont = neb_cont
self.inc_met = neb_met
self.dust_model = dustmodel
mu = 0.3
epsilon = 0.
self.ta = self.ta_arr[self.mi]
self.wave = self.wave_arr[self.mi]
[T1, T2] = numpy.meshgrid(self.tg, self.ta)
tgi = numpy.argmin(numpy.abs(self.tg - self.ta))
self.tg = self.ta[tgi]
if len(self.neb_wave) != len(self.wave):
self.neb_cont = griddata(self.neb_wave, self.neb_cont, self.wave)
self.neb_hlines = griddata(self.neb_wave, self.neb_hlines,
self.wave)
neb_metaln = numpy.zeros((len(self.wave), 3))
for i in range(3):
neb_metaln[:, i] = griddata(self.neb_wave,
self.neb_metal[:, i], self.wave)
self.neb_metal = neb_metaln
self.neb_wave = self.wave
#quietprint("Metallicity "+str(self.mi+1)+":")
#print ".ised file: "+files[abs(SSP)]
sed = self.sed_arr[self.mi]
strm = self.strm_arr[self.mi]
rmtm = self.rmtm_arr[self.mi]
self.iw = self.iw_arr[self.mi]
metal = str((self.metal_arr[self.mi]))[12:-3].strip()
#quietprint(metal[self.mi] + "\nInclude nebular emission: " + str(add_nebular))
SSP_Z = float(re.split("Z=?", metal)[1])
#print SSP_Z,
if SSP_Z <= 0.0004: neb_z = 0
elif SSP_Z > 0.0004 and SSP_Z <= 0.004: neb_z = 1
elif SSP_Z > 0.004: neb_z = 2
#print neb_z
if self.dust_model == "charlot":
ATT = numpy.empty([len(self.wave), len(self.ta)])
tv = ((self.tauv / 1.0857) * numpy.ones(len(self.ta)))
tv[self.ta > 1e7] = mu * self.tauv
lam = numpy.array((5500 / self.wave)**0.7)
ATT[:, :] = (numpy.exp(-1 * numpy.outer(lam, tv)))
elif self.dust_model == "calzetti":
ATT = numpy.ones([len(self.wave), len(self.ta)])
k = numpy.zeros_like(self.wave)
w0 = [self.wave <= 1200]
w1 = [self.wave < 6300]
w2 = [self.wave >= 6300]
w_u = self.wave / 1e4
x1 = numpy.argmin(numpy.abs(self.wave - 1200))
x2 = numpy.argmin(numpy.abs(self.wave - 1250))
k[w2] = 2.659 * (-1.857 + 1.040 / w_u[w2])
k[w1] = 2.659 * (-2.156 + (1.509 / w_u[w1]) -
(0.198 / w_u[w1]**2) + (0.011 / w_u[w1]**3))
k[w0] = k[x1] + ((self.wave[w0] - 1200.) * (k[x1] - k[x2]) /
(self.wave[x1] - self.wave[x2]))
k += 4.05
k[k < 0.] = 0.
tv = self.tauv * k / 4.05
for ti in range(0, len(self.ta)):
ATT[:, ti] *= numpy.power(10, -0.4 * tv)
elif self.dust_model == "calzetti2":
ATT = numpy.ones([len(self.wave), len(self.ta)])
k = numpy.zeros_like(self.wave)
w0 = [self.wave <= 1000]
w1 = [(self.wave > 1000) * (self.wave < 6300)]
w2 = [self.wave >= 6300]
w_u = self.wave / 1e4
k[w2] = 2.659 * (-1.857 + 1.040 / w_u[w2])
k[w1] = 2.659 * (-2.156 + (1.509 / w_u[w1]) -
(0.198 / w_u[w1]**2) + (0.011 / w_u[w1]**3))
p1 = self.dust_func(self.wave, 27, 4, 5.5, 0.08) + self.dust_func(
self.wave, 185, 90, 2, 0.042)
k[w0] = p1[w0] / (p1[w1][0] / k[w1][0])
k += 4.05
k[k < 0.] = 0.
tv = self.tauv * k / 4.05
for ti in range(0, len(self.ta)):
ATT[:, ti] *= numpy.power(10, -0.4 * tv)
elif self.dust_model == "smc":
ai = [185., 27., 0.005, 0.01, 0.012, 0.03]
bi = [90., 5.5, -1.95, -1.95, -1.8, 0.]
ni = [2., 4., 2., 2., 2., 2.]
li = [0.042, 0.08, 0.22, 9.7, 18., 25.]
eta = numpy.zeros_like(self.wave)
for i in xrange(len(ai)):
eta += self.dust_func(self.wave, ai[i], bi[i], ni[i], li[i])
Rv = 2.93
Ab = self.tauv * (1 + (1 / Rv))
print numpy.exp(self.tauv * eta)
ATT = numpy.ones([len(self.wave), len(self.ta)])
for ti in range(0, len(self.ta)):
ATT[:, ti] *= numpy.power(10, -0.4 * (Ab * eta))
#Offset added to renormalise from B to V band
#ATT[:,ti] *= numpy.exp(-1*self.tauv*eta)
elif self.dust_model == "lmc":
ai = [175., 19., 0.023, 0.005, 0.006, 0.02]
bi = [90., 4.0, -1.95, -1.95, -1.8, 0.]
ni = [2., 4.5, 2., 2., 2., 2.]
li = [0.046, 0.08, 0.22, 9.7, 18., 25.]
eta = numpy.zeros_like(self.wave)
for i in xrange(len(ai)):
eta += self.dust_func(self.wave, ai[i], bi[i], ni[i], li[i])
Rv = 3.16
Ab = self.tauv * (1 + (1 / Rv))
ATT = numpy.ones([len(self.wave), len(self.ta)])
for ti in range(0, len(self.ta)):
ATT[:, ti] *= numpy.power(10, -0.4 * (Ab * eta))
#Offset added to renormalise from B to V band
#ATT[:,ti] *= numpy.exp(-1*self.tauv*eta)
elif self.dust_model == "mw":
ai = [165., 14., 0.045, 0.002, 0.002, 0.012]
bi = [90., 4., -1.95, -1.95, -1.8, 0.]
ni = [2., 6.5, 2., 2., 2., 2.]
li = [0.047, 0.08, 0.22, 9.7, 18., 25.]
eta = numpy.zeros_like(self.wave)
for i in xrange(len(ai)):
eta += self.dust_func(self.wave, ai[i], bi[i], ni[i], li[i])
Rv = 3.08
Ab = self.tauv * (1 + (1 / Rv))
ATT = numpy.ones([len(self.wave), len(self.ta)])
for ti in range(0, len(self.ta)):
ATT[:, ti] *= numpy.power(10, -0.4 * (Ab * eta))
#Offset added to renormalise from B to V band
#ATT[:,ti] *= numpy.exp(-1*self.tauv*eta)
"""
SECTION 1
First calculate and store those parameters that are functions of the age array
'ta' only - these are the same for every model to be made. The parameters are
the age array TP, the time interval array DT, the interpolation coefficient
'a' and the interpolation indices J. Each are stored in cell arrays of size ks,
with the data corresponding to the original age array first, and the
interpolated data second.
"""
self.TP = {}
self.A = {}
self.J = {}
self.DT = {}
for ai in range(tgi + 1):
#Calculate taux2: the reverse age array; remove those values which
#are less than the first non-zero entry of taux1 - these values
#are treated differently in the original BC code
taux1 = self.ta[:ai + 1]
taux2 = self.ta[ai] - self.ta[ai::-1]
if max(taux1) > 0.:
taux2 = numpy.delete(
taux2,
numpy.where(taux2 < taux1[numpy.flatnonzero(taux1)[0]]))
#Remove values common to taux1 and taux2; calulate array TP
[T1, T2] = numpy.meshgrid(taux1, taux2)
[i, j] = numpy.where(T1 - T2 == 0)
taux2 = numpy.delete(taux2, i)
self.TP[ai] = self.ta[ai] - numpy.concatenate(
(taux1, taux2), axis=0)
l = len(taux2)
#If taux2 has entries, calculate the interpolation parameters a and J.
#The indicies correspond to those values of 'ta' which are just below
#the entries in taux2. They are calculated by taking the difference
#between the two arrays, then finding the last negative entry in the
#resulting array.
if l == 0:
self.J[ai] = numpy.array([])
self.A[ai] = numpy.array([])
if l > 0:
[T1, T2] = numpy.meshgrid(self.ta, taux2)
T = T1 - T2
T[numpy.where(T <= 0)] = 0
T[numpy.where(T != 0)] = 1
T = numpy.diff(T, 1, 1)
(i, self.J[ai]) = T.nonzero()
self.A[ai] = (
numpy.log10(taux2 / self.ta[self.J[ai]]) /
numpy.log10(self.ta[self.J[ai] + 1] / self.ta[self.J[ai]]))
#Calculate age difference array: the taux arrays are joined and
#sorted, the differences calculated, then rearranged back to the order
#of the original taux values.
taux = numpy.concatenate((taux1, taux2), axis=0)
taux.sort()
b = numpy.searchsorted(taux, taux1)
c = numpy.searchsorted(taux, taux2)
order = numpy.concatenate((b, c))
d = numpy.diff(taux)
dt = numpy.append(d, 0) + numpy.append(0, d)
self.DT[ai] = numpy.copy(dt[order])
SED = numpy.empty([len(self.wave)])
Nlyman = numpy.empty([1])
Nlyman_final = numpy.empty([1])
beta = numpy.empty([1])
norm = numpy.empty([1])
STR = numpy.empty([tgi + 1])
SFR = numpy.empty([tgi + 1])
W = {}
# metal=[str((self.data[1]))[12:-3].strip()]*len(params.metallicities)
RMr = numpy.empty([tgi + 1])
PRr = numpy.empty([tgi + 1])
URr = numpy.empty([tgi + 1])
Tr = numpy.empty([tgi + 1])
"""
SECTION 2
Now calculate the integration coefficients w, and store them in the
cell array W. Also calculate the stellar mass fraction str. The so
array is expanded and used by each successive iteration of the inner
loop (ai). The outer loop repeats the operation for each tau value.
"""
prgas = numpy.zeros(tgi + 1)
for ai in xrange(tgi + 1):
j = self.J[ai] #Interpolation indices
tp = self.TP[ai] #Integration timescale
pgas = numpy.zeros_like(tp)
if ai == 0:
prgas = numpy.zeros_like(self.ta)
else:
i = numpy.where(tp <= self.ta[ai - 1])
ii = numpy.where(tp > self.ta[ai - 1])
pgas[i] = griddata(self.ta, prgas, tp[i])
pgas[ii] = prgas[ai - 1]
#print prgas[ai]
tbins = numpy.logspace(0, numpy.log10(max(tp)), 1000)
npgas = numpy.zeros_like(tbins)
if self.sfh_law == 'exp':
if self.tau > 0.:
sr = (1 + epsilon * pgas) * numpy.exp(
-1 * tp / self.tau) / abs(self.tau)
norma = 1
if len(sr) > 1:
i = numpy.where(tbins <= self.ta[ai - 1])
ii = numpy.where(tbins > self.ta[ai - 1])
npgas[i] = griddata(self.ta, prgas, tbins[i])
npgas[ii] = prgas[ai - 1]
norma = simps(
(1 + epsilon * npgas) *
numpy.exp(-1 * tbins / self.tau) / abs(self.tau),
tbins)
sr /= norma
elif self.tau < 0.:
sr = numpy.exp(-1 * tp / self.tau) / abs(self.tau)
norma = 1
self.sr = sr
if len(sr) > 1:
norma = simps(
numpy.exp(-1 * tbins / self.tau) / abs(self.tau),
tbins)
sr /= norma
#print sr[0]
self.norma = norma
w = sr * self.DT[ai] / 2
w1 = numpy.array(w[:ai + 1])
W[0, ai] = w1
strr = numpy.array(numpy.dot(w1, strm[:ai + 1]))
rm = numpy.array(numpy.dot(w1, rmtm[:ai + 1]))
l = len(self.A[ai])
if l > 0:
w2 = w[ai + 1:ai + l + 1]
wa = w2 * self.A[ai]
wb = w2 - wa
W[1, ai] = wa
W[2, ai] = wb
strr += (numpy.dot(wb, strm[j]) +
numpy.dot(wa, strm[j + 1]))
rm += (numpy.dot(wb, rmtm[j]) + numpy.dot(wa, rmtm[j + 1]))
if strr > 1: strr = 1
if self.tau > 0.:
ugas = numpy.exp(-1 * self.ta[ai] / self.tau)
elif self.tau < 0.:
ugas = numpy.exp(-1 * self.ta[ai] / self.tau) / numpy.exp(
-1 * max(self.ta) / self.tau)
#ugas = 1.
#Processed gas = gas formed into stars - mass in stars - remnants
prgas[ai] = 1 - ugas - strr - rm
if prgas[ai] < 0.: prgas[ai] = 0
#print prgas[ai]
URr[ai] = ugas
PRr[ai] = prgas[ai]
RMr[ai] = rm
Tr[ai] = simps(
numpy.exp(-1 * numpy.sort(tp) / self.tau) / self.tau,
numpy.sort(tp))
STR[ai] = strr
if self.tau > 0:
SFR[ai] = (1 + epsilon * prgas[ai]) * numpy.exp(
-self.ta[ai] / self.tau) / abs(self.tau) / norma
elif self.tau < 0:
SFR[ai] = numpy.exp(-self.ta[ai] / self.tau) / abs(
self.tau) / norma
#print SFR[ai,ti,mi]
#self.SN = float(snn)
SFR[ai] /= STR[ai]
else:
if self.sfh_law == 'pow':
sfr = self._sfh_pow
elif self.sfh_law == 'del':
sfr = self._sfh_del
elif self.sfh_law == 'tru':
sfr = self._sfh_tru
sr = sfr(tp, self.tau)
self.tp = tp
norma = 1
self.sr = sr
if len(sr) > 1:
norma = simps(sfr(tbins, self.tau), tbins)
sr /= norma
self.norma = norma
#print sr[0]
w = sr * self.DT[ai] / 2
w1 = numpy.array(w[:ai + 1])
W[0, ai] = w1
strr = numpy.array(numpy.dot(w1, strm[:ai + 1]))
rm = numpy.array(numpy.dot(w1, rmtm[:ai + 1]))
l = len(self.A[ai])
if l > 0:
w2 = w[ai + 1:ai + l + 1]
wa = w2 * self.A[ai]
wb = w2 - wa
W[1, ai] = wa
W[2, ai] = wb
strr += (numpy.dot(wb, strm[j]) +
numpy.dot(wa, strm[j + 1]))
rm += (numpy.dot(wb, rmtm[j]) + numpy.dot(wa, rmtm[j + 1]))
if strr > 1: strr = 1
if self.tau > 0.:
ugas = sfr(self.ta, self.tau)[ai]
elif self.tau < 0.:
ugas = sfr(self.ta, self.tau)[ai] / sfr(
max(self.ta), self.tau)
#ugas = 1.
#Processed gas = gas formed into stars - mass in stars - remnants
prgas[ai] = 1 - ugas - strr - rm
if prgas[ai] < 0.: prgas[ai] = 0
#print prgas[ai]
URr[ai] = ugas
PRr[ai] = prgas[ai]
RMr[ai] = rm
Tr[ai] = simps(sfr(numpy.sort(tp) / 1.e9, self.tau),
numpy.sort(tp))
STR[ai] = strr
if self.tau > 0:
SFR[ai] = (1 + epsilon * prgas[ai]) * sfr(
self.ta, self.tau)[ai] / norma
elif self.tau < 0:
SFR[ai] = sfr(self.ta[ai], self.tau) / norma
#print SFR[ai,ti,mi]
#self.SN = float(snn)
SFR[ai] /= STR[ai]
"""
SECTION 3
Finally, for each tauv/tau/tg combination, perform a weighted
sum of the S.S.params. spectral energy distribution 'sed1' to obtain the
model S.E.D. 'y'. Add each record to the SED array.
"""
sed1 = sed * ATT #dust-attenuated SED
ai = tgi
y = numpy.zeros([1, self.iw])
y_nodust = numpy.zeros([1, self.iw])
j = self.J[ai]
w1 = W[0, ai]
wa = W[1, ai]
wb = W[2, ai]
for i in range(ai):
y += (w1[i] * sed1[:, i])
y_nodust += (w1[i] * sed[:, i])
for i in range(len(wb)):
y += (wb[i] * sed1[:, j[i]] + wa[i] * sed1[:, j[i] + 1])
y_nodust += (wb[i] * sed[:, j[i]] + wa[i] * sed[:, j[i] + 1])
Nly = self.calc_lyman(self.wave, numpy.nan_to_num(y_nodust[0]))
#print Nly
if Nly > 0.:
Nlyman = numpy.log10(Nly)
else:
Nlyman = 0.
total = (self.neb_cont * self.inc_cont) + self.neb_hlines + (
self.neb_metal[:, neb_z] * self.inc_met)
total *= 2.997925e18 / (self.wave**2) #Convert to Flambda
total *= (Nly * (1 - self.fesc))
y += total
Nly = self.calc_lyman(self.wave, numpy.nan_to_num(y[0] / STR[ai]))
#print Nly
self.fesc_tot = (self.fesc * Nly) / 10**Nlyman
if Nly > 0.:
Nlyman_final = numpy.log10(Nly) + 33. + numpy.log10(3.826)
if self.fesc > 0.:
Nlyman_final = numpy.log10(10**Nlyman_final * self.fesc)
elif self.fesc == 0:
Nlyman_final = 0.
else:
Nlyman_final = 0.
beta = self.calc_beta(self.wave, y[0])
#print ai,ai1
#print STR[ai1,ti,mi]
SED[:] = y / STR[ai] #normalised to 1 solar mass
norm = simps(
numpy.exp(-1 *
numpy.logspace(0, numpy.log10(self.ta[tgi]), 10000) /
self.tau),
numpy.logspace(0, numpy.log10(self.ta[tgi]), 10000))
STR = STR[tgi]
SFR = SFR[tgi]
self.SED = SED
self.SFR = SFR / STR
self.STR = STR
self.beta = beta
self.Nly = Nlyman_final
self.Ms = 1.
def _volume_differential_comoving(self,z_low,z_upp,N=100):
z_arr = np.linspace(z_low, z_upp, N)
dVC = self.cosmo.differential_comoving_volume(z_arr).to(u.Mpc**3 / u.deg**2).value
return simps(dVC,z_arr)
erange = (energy[0], energy[-1])
emask = (energy >= emin) & (energy <= emax
) # bool to make a mapping between energy and dos
list_pup = [l.split()[3] for l in open(file, 'rb')]
list_pup.pop(0)
p_up = np.array([float(i) for i in list_pup]) # extract p_up
list_pdown = [l.split()[4] for l in open(file, 'rb')]
list_pdown.pop(0)
p_down = np.array([float(i) for i in list_pdown]) # extract p_down
x = energy[emask]
y1 = p_up[emask]
y2 = p_down[emask]
pbc_up = simps(y1 * x, x) / simps(y1, x)
pbc_down = simps(y2 * x, x) / simps(y2, x)
pbc = []
pbc.append(pbc_up)
pbc.append(pbc_down)
###### calculaton of d-band center ######
## same energy set ##
list_dup = [l.split()[5] for l in open(file, 'rb')]
list_dup.pop(0)
d_up = np.array([float(i) for i in list_dup]) # extract d_up
list_ddown = [l.split()[6] for l in open(file, 'rb')]
list_ddown.pop(0)
d_down = np.array([float(i) for i in list_ddown]) # extract d_down
g = pyrads.SetupGrids.make_grid(Ts,
Tstrat,
N_press,
wavenr_min,
wavenr_max,
dwavenr,
params,
RH=params.RH)
# compute optical thickness:
# -> this is the computationally most intensive step
g.tau, g.omega = pyrads.OpticalThickness.compute_tau_omega_H2ON2(g.p,
g.T,
g.q,
g,
params,
RH=params.RH)
# compute Planck functions etc:
# -> here: fully spectrally resolved!
T_2D = np.tile(g.T, (g.Nn, 1)).T # [press x wave]
g.B_surf = np.pi * pyrads.Planck.Planck_n(g.n, Ts) # [wave]
g.B = np.pi * pyrads.Planck.Planck_n(g.wave, T_2D) # [press x wave]
# compute OLR etc:
olr_spec = pyrads.Get_Fluxes.Fplus_alternative(
0, g) # (spectrally resolved=irradiance)
olr = simps(olr_spec, g.n)
print("OLR = ", olr)
def overlapArr(self, arr1, arr2):
tempoverlap = np.zeros(self.n)
for i in range(self.n):
psi_comb = np.real(np.conjugate(arr1[i]) * arr2[i])
tempoverlap[i] = simps(psi_comb, self.x)
return tempoverlap
