def cos_square_avg(J):
global tol
global nint
norm,error1 = quadrature(func_norm,0,pi,args=(J,),tol=tol,maxiter=nint)
avg,error2 = quadrature(func_avg,0,pi,args=(J,),tol=tol,maxiter=nint)
avg *= 1.0/norm
return avg
def complex_integral(func,a,b,args,intype='stupid'):
real_func = lambda z: np.real(func(z,*args))
imag_func = lambda z: np.imag(func(z,*args))
if intype == 'quad':
real_int = integ.quad(real_func,a,b)
imag_int = integ.quad(imag_func,a,b)
# print(real_int)
# print(imag_int)
return real_int[0] + 1j * imag_int[0]
elif intype == 'quadrature':
real_int = integ.quadrature(real_func,a,b)
imag_int = integ.quadrature(imag_func,a,b)
# print(real_int)
# print(imag_int)
return real_int[0] + 1j * imag_int[0]
elif intype == 'romberg':
real_int = integ.romberg(real_func,a,b)
imag_int = integ.romberg(imag_func,a,b)
# print(real_int)
# print(imag_int)
return real_int + 1j * imag_int
elif intype == 'stupid':
Npoints = 500
z,dz = np.linspace(a,b,Npoints,retstep=True)
real_int = np.sum(real_func(z))*dz
imag_int = np.sum(imag_func(z))*dz
# print(real_int)
# print(imag_int)
return real_int + 1j*imag_int
def TR(self,**kwargs):
"""
NAME:
TR
PURPOSE:
Calculate the radial period for a flat rotation curve
INPUT:
scipy.integrate.quadrature keywords
OUTPUT:
T_R(R,vT,vT)*vc/ro + estimate of the error
HISTORY:
2010-05-13 - Written - Bovy (NYU)
"""
if hasattr(self,'_TR'):
return self._TR
(rperi,rap)= self.calcRapRperi()
if rap == rperi: #Rough limit
#TR=kappa
kappa= m.sqrt(2.)/self._R
self._TR= nu.array([2.*m.pi/kappa,0.])
return self._TR
Rmean= m.exp((m.log(rperi)+m.log(rap))/2.)
TR= 0.
if Rmean > rperi:
TR+= rperi*nu.array(integrate.quadrature(_TRFlatIntegrandSmall,
0.,m.sqrt(Rmean/rperi-1.),
args=((self._R*self._vT)**2/rperi**2.,),
**kwargs))
if Rmean < rap:
TR+= rap*nu.array(integrate.quadrature(_TRFlatIntegrandLarge,
0.,m.sqrt(1.-Rmean/rap),
args=((self._R*self._vT)**2/rap**2.,),
**kwargs))
self._TR= m.sqrt(2.)*TR
return self._TR
def TR(self,**kwargs): #pragma: no cover
"""
NAME:
TR
PURPOSE:
Calculate the radial period for a power-law rotation curve
INPUT:
scipy.integrate.quadrature keywords
OUTPUT:
T_R(R,vT,vT)*vc/ro + estimate of the error
HISTORY:
2010-12-01 - Written - Bovy (NYU)
"""
if hasattr(self,'_TR'):
return self._TR
(rperi,rap)= self.calcRapRperi(**kwargs)
if nu.fabs(rap-rperi)/rap < 10.**-4.: #Rough limit
self._TR= 2.*m.pi/epifreq(self._pot,self._R,use_physical=False)
return self._TR
Rmean= m.exp((m.log(rperi)+m.log(rap))/2.)
EL= self.calcEL(**kwargs)
E, L= EL
TR= 0.
if Rmean > rperi:
TR+= integrate.quadrature(_TRAxiIntegrandSmall,
0.,m.sqrt(Rmean-rperi),
args=(E,L,self._pot,rperi),
**kwargs)[0]
if Rmean < rap:
TR+= integrate.quadrature(_TRAxiIntegrandLarge,
0.,m.sqrt(rap-Rmean),
args=(E,L,self._pot,rap),
**kwargs)[0]
self._TR= 2.*TR
return self._TR
def _calc_or(self,Rmean,rperi,rap,E,L,fixed_quad,**kwargs):
Tr= 0.
if Rmean > rperi and not fixed_quad:
Tr+= nu.array(integrate.quadrature(_TrSphericalIntegrandSmall,
0.,m.sqrt(Rmean-rperi),
args=(E,L,self._2dpot,
rperi),
**kwargs))[0]
elif Rmean > rperi and fixed_quad:
Tr+= integrate.fixed_quad(_TrSphericalIntegrandSmall,
0.,m.sqrt(Rmean-rperi),
args=(E,L,self._2dpot,
rperi),
n=10,**kwargs)[0]
if Rmean < rap and not fixed_quad:
Tr+= nu.array(integrate.quadrature(_TrSphericalIntegrandLarge,
0.,m.sqrt(rap-Rmean),
args=(E,L,self._2dpot,
rap),
**kwargs))[0]
elif Rmean < rap and fixed_quad:
Tr+= integrate.fixed_quad(_TrSphericalIntegrandLarge,
0.,m.sqrt(rap-Rmean),
args=(E,L,self._2dpot,
rap),
n=10,**kwargs)[0]
Tr= 2.*Tr
return 2.*nu.pi/Tr
def _calc_angler(self,Or,r,Rmean,rperi,rap,E,L,vr,fixed_quad,**kwargs):
if r < Rmean:
if r > rperi and not fixed_quad:
wr= Or*integrate.quadrature(_TrSphericalIntegrandSmall,
0.,m.sqrt(r-rperi),
args=(E,L,self._2dpot,rperi),
**kwargs)[0]
elif r > rperi and fixed_quad:
wr= Or*integrate.fixed_quad(_TrSphericalIntegrandSmall,
0.,m.sqrt(r-rperi),
args=(E,L,self._2dpot,rperi),
n=10,**kwargs)[0]
else:
wr= 0.
if vr < 0.: wr= 2*m.pi-wr
else:
if r < rap and not fixed_quad:
wr= Or*integrate.quadrature(_TrSphericalIntegrandLarge,
0.,m.sqrt(rap-r),
args=(E,L,self._2dpot,rap),
**kwargs)[0]
elif r < rap and fixed_quad:
wr= Or*integrate.fixed_quad(_TrSphericalIntegrandLarge,
0.,m.sqrt(rap-r),
args=(E,L,self._2dpot,rap),
n=10,**kwargs)[0]
else:
wr= m.pi
if vr < 0.:
wr= m.pi+wr
else:
wr= m.pi-wr
return wr
def _calc_op(self,Or,Rmean,rperi,rap,E,L,fixed_quad,**kwargs):
#Azimuthal period
I= 0.
if Rmean > rperi and not fixed_quad:
I+= nu.array(integrate.quadrature(_ISphericalIntegrandSmall,
0.,m.sqrt(Rmean-rperi),
args=(E,L,self._2dpot,
rperi),
**kwargs))[0]
elif Rmean > rperi and fixed_quad:
I+= integrate.fixed_quad(_ISphericalIntegrandSmall,
0.,m.sqrt(Rmean-rperi),
args=(E,L,self._2dpot,rperi),
n=10,**kwargs)[0]
if Rmean < rap and not fixed_quad:
I+= nu.array(integrate.quadrature(_ISphericalIntegrandLarge,
0.,m.sqrt(rap-Rmean),
args=(E,L,self._2dpot,
rap),
**kwargs))[0]
elif Rmean < rap and fixed_quad:
I+= integrate.fixed_quad(_ISphericalIntegrandLarge,
0.,m.sqrt(rap-Rmean),
args=(E,L,self._2dpot,rap),
n=10,**kwargs)[0]
I*= 2*L
return I*Or/2./nu.pi
def p_avg(x):
global tol
global nint
norm,error1 = quadrature(func_norm,-1,1,args=(x,),tol=tol,maxiter=nint)
avg,error2 = quadrature(func_avg,-1,1,args=(x,),tol=tol,maxiter=nint)
avg *= 1.0/norm
return avg
def p_avg(p0,a1,a3,Ex,T,tol=1.0e-3,maxiter=50):
args=(p0,a1,a3,Ex,T)
norm,error_norm = quadrature(kernel,0,pi,args=args,tol=tol,maxiter=maxiter)
cos_avg,error_cos = quadrature(func_cos_avg,0,pi,args=args,tol=tol,maxiter=maxiter)
cos_square_avg,error_cos_sqr = quadrature(func_cos_sqr_avg,0,pi,args=args,tol=tol,maxiter=maxiter)
cos_avg *= 1.0/norm
cos_square_avg *= 1.0/norm
return p0*cos_avg + (a1 + (a3 - a1)*cos_square_avg)*Ex
def _calc_anglez(self,Or,Op,ar,z,r,Rmean,rperi,rap,E,L,Lz,vr,axivz,
fixed_quad,**kwargs):
#First calculate psi
i= nu.arccos(Lz/L)
sinpsi= z/r/nu.sin(i)
if sinpsi > 1. and sinpsi < (1.+10.**-7.):
sinpsi= 1.
if sinpsi < -1. and sinpsi > (-1.-10.**-7.):
sinpsi= -1.
psi= nu.arcsin(sinpsi)
if axivz > 0.: psi= nu.pi-psi
psi= psi % (2.*nu.pi)
#Calculate dSr/dL
dpsi= Op/Or*2.*nu.pi #this is the full I integral
if r < Rmean:
if not fixed_quad:
wz= L*integrate.quadrature(_ISphericalIntegrandSmall,
0.,m.sqrt(r-rperi),
args=(E,L,self._2dpot,
rperi),
**kwargs)[0]
elif fixed_quad:
wz= L*integrate.fixed_quad(_ISphericalIntegrandSmall,
0.,m.sqrt(r-rperi),
args=(E,L,self._2dpot,
rperi),
n=10,**kwargs)[0]
if vr < 0.: wz= dpsi-wz
else:
if not fixed_quad:
wz= L*integrate.quadrature(_ISphericalIntegrandLarge,
0.,m.sqrt(rap-r),
args=(E,L,self._2dpot,
rap),
**kwargs)[0]
elif fixed_quad:
wz= L*integrate.fixed_quad(_ISphericalIntegrandLarge,
0.,m.sqrt(rap-r),
args=(E,L,self._2dpot,
rap),
n=10,**kwargs)[0]
if vr < 0.:
wz= dpsi/2.+wz
else:
wz= dpsi/2.-wz
#Add everything
wz= -wz+psi+Op/Or*ar
return wz
def find_gb_omega(omega, energy_low, energy_high, system, efermi, temp, delta): """ Integrate gb_integrand function over range of energies to find Gilbert damping """ scaling = 1 / omega out = (delta**2)*(scaling) * integrate.quadrature(lambda energy: gb_integrand(energy,omega,system,efermi,temp), energy_low, energy_high, vec_func = False,tol=10e-5)[0] return out
def c(ni, nf): # eigenfunctions are real
return integrate.quadrature(
lambda x: eigen_f(nf, x) * eigen_i(ni, x), # < bra | ket >
0., pi,
rtol=1e-5, maxiter=1000,
vec_func=False
)
def luminosity_distance(z, k=0):
''' Calculate the luminosity distance for a given redshift.
Parameters:
* z (float or array): the redshift(s)
* k = 0 (float): the curvature constant.
Returns:
The luminosity distance in Mpc
'''
if not (type(z) is np.ndarray): #Allow for passing a single z
z = np.array([z])
n = len(z)
if const.lam == 0:
denom = np.sqrt(1+2*const.q0*z) + 1 + const.q0*z
dlum = (const.c*z/const.H0)*(1 + z*(1-const.q0)/denom)
return dlum
else:
dlum = np.zeros(n)
for i in xrange(n):
if z[i] <= 0:
dlum[i] = 0.0
else:
dlum[i] = quadrature(_ldist, 0, z[i])[0]
if k > 0:
dlum = np.sinh(np.sqrt(k)*dlum)/np.sqrt(k)
elif k < 0:
dlum = np.sin(np.sqrt(-k)*dlum)/np.sqrt(-k)
return outputify(const.c*(1+z)*dlum/const.H0)
def ps_to_xi(k,ps,r,precision='mid'):
xi = 0 * r
if precision=='low':
from scipy.integrate import trapz
from scipy import sin
for i in range(len(r)):
xi[i] = trapz((ps/k) * sin(k*r[i]) / (k*r[i]),k)
elif precision=='high':
from scipy import sin
from scipy.integrate import quad,quadrature
from scipy.interpolate import interp1d
for i in range(len(r)):
psi = interp1d(k,ps)
core = lambda k: (psi(k)/k) * sin(k*r[i]) / (k*r[i])
A = quadrature(core,min(k),2.0/r[i],tol=1e-3)
xi[i] = A[0]
else:
from scipy.integrate import trapz
from scipy import sin
from pylab import find
import numpy as np
for i in range(len(r)):
cutoff = np.min(find(k>2.0/r[i]))
kl = k[1:cutoff]
psl = ps[1:cutoff]
i1 = trapz((psl/kl) * sin(kl*r[i]) / (kl*r[i]),kl)
psh = ps[cutoff+1:len(k)]
kh = k[cutoff+1:len(k)]
i2 = trapz((psh/kh) * sin(kh*r[i]) / (kh*r[i]),kh)
xi[i] = i1+i2
return xi
def get_mmax(self, catalogue, config):
'''Calculate mmax
:return: **mmax** Maximum magnitude and **mmax_sig** corresponding
uncertainty
:rtype: Float
'''
obsmax, obsmaxsig = _get_observed_mmax(catalogue, config)
mmin = config['input_mmin']
beta = config['b-value'] * np.log(10.)
neq, mmin = _get_magnitude_vector_properties(catalogue, config)
mmax = deepcopy(obsmax)
d_t = np.inf
iterator = 0
while d_t > config['tolerance']:
delta = quadrature(_ks_intfunc, mmin, mmax,
args = [neq, mmax, mmin, beta])[0]
#print mmin, neq, delta, mmax
tmmax = obsmax + delta
d_t = np.abs(tmmax - mmax)
mmax = deepcopy(tmmax)
iterator += 1
if iterator > config['maximum_iterations']:
print 'Kijko-Sellevol estimator reached maximum # of iterations'
d_t = -np.inf
return mmax, np.sqrt(obsmaxsig ** 2. + delta ** 2.)
def get_mmax(self, catalogue, config):
'''Calculate maximum magnitude
:return: **mmax** Maximum magnitude and **mmax_sig** corresponding
uncertainty
:rtype: Float
'''
obsmax, obsmaxsig = _get_observed_mmax(catalogue, config)
beta = config['b-value'] * np.log(10.)
sigbeta = config['sigma-b'] * np.log(10.)
neq, mmin = _get_magnitude_vector_properties(catalogue, config)
pval = beta / (sigbeta ** 2.)
qval = (beta / sigbeta) ** 2.
mmax = deepcopy(obsmax)
d_t = np.inf
iterator = 0
while d_t > config['tolerance']:
rval = pval / (pval + mmax - mmin)
ldelt = (1. / (1. - (rval ** qval))) ** neq
delta = ldelt * quadrature(_ksb_intfunc, mmin, mmax,
args = [neq, mmin, pval, qval])[0]
tmmax = obsmax + delta
d_t = np.abs(tmmax - mmax)
mmax = deepcopy(tmmax)
iterator += 1
if iterator > config['max_iterations']:
print 'Kijko-Sellevol-Bayes estimator reached'
print 'maximum # of iterations'
d_t = -np.inf
return mmax, np.sqrt(obsmaxsig ** 2. + delta ** 2.)
def CalculateEnergyFlux(self,modelName,params):
model = self.eFluxModels[modelName]
#self.shit=params
#print params
try:
args=params.tolist()
except(AttributeError):
args = tuple(params)
#print args
if (modelName == 'Band\'s GRB, Epeak') or (modelName =='Power Law w. 2 Breaks') or (modelName =='Broken Power Law'):
val,_, = quadrature(model, self.eMin,self.eMax,args=args,tol=1.49e-10, rtol=1.49e-10, maxiter=200)
val = val*keV2erg
return val
val,_, = quad(model, self.eMin,self.eMax,args=args[0], epsrel= 1.e-8 )
val = val*keV2erg
return val
def comoving_distance(z,cosmo=None):
"""
Calculate the line of sight comoving distance
parameters
----------
z: float
redshift
cosmo: astropy.cosmology object, optional
cosmology object specifying cosmology. If None, FlatLambdaCDM(H0=70,Om0=0.3)
returns
-------
DC: float
Comoving line of sight distance in Mpc
"""
if cosmo==None:
cosmo = astropy.cosmology.FlatLambdaCDM(H0=70, Om0=0.3)
f = lambda zz: 1.0/_Ez(zz, cosmo.Om0, cosmo.Ok0, cosmo.Ode0)
DC = integrate.quadrature(f,0.0,z)[0]
return hubble_distance(cosmo.H0.value)*DC
def test_quadrature_rtol(self):
def myfunc(x, n, z): # Bessel function integrand
return 1e90 * cos(n * x - z * sin(x)) / pi
val, err = quadrature(myfunc, 0, pi, (2, 1.8), rtol=1e-10)
table_val = 1e90 * 0.30614353532540296487
assert_allclose(val, table_val, rtol=1e-10)
def comoving_volume(z,dw,cosmo=None):
"""
Calculate comoving volume
parameters
----------
z: float
redshift
dw: float
solid angle
cosmo: astropy.cosmology object, optional
cosmology object specifying cosmology. If None, FlatLambdaCDM(H0=70,Om0=0.3)
returns
-------
VC: float
comoving volume in Mpc^3
"""
if cosmo==None:
cosmo = astropy.cosmology.FlatLambdaCDM(H0=70, Om0=0.3)
DH = hubble_distance(cosmo.H0.value)
f = lambda zz: DH*((1.0+zz)**2.0*angular_diameter_distance(zz,cosmo)**2.0)/(_Ez(zz, cosmo.Om0, cosmo.Ok0, cosmo.Ode0))
VC = integrate.quadrature(f,0.0,z,vec_func=False)[0]*dw
return VC
def test_quadrature(self):
# Typical function with two extra arguments:
def myfunc(x, n, z): # Bessel function integrand
return cos(n*x-z*sin(x))/pi
val, err = quadrature(myfunc, 0, pi, (2, 1.8))
table_val = 0.30614353532540296487
assert_almost_equal(val, table_val, decimal=7)
def test_quadrature_single_args(self):
def myfunc(x, n):
return 1e90 * cos(n * x - 1.8 * sin(x)) / pi
val, err = quadrature(myfunc, 0, pi, args=2, rtol=1e-10)
table_val = 1e90 * 0.30614353532540296487
assert_allclose(val, table_val, rtol=1e-10)
def lumdist(z, k=0): ''' Calculate the luminosity distance for redshift z Parameters: * z (float or numpy array): the redshift or redshifts Returns: The luminosity distance(s) in Mpc ''' if not (type(z) is np.ndarray): #Allow for passing a single z z = np.array([z]) n = len(z) if lam == 0: denom = np.sqrt(1+2*q0*z) + 1 + q0*z dlum = (c*z/h0)*(1 + z*(1-q0)/denom) return dlum else: dlum = np.zeros(n) for i in xrange(n): if z[i] <= 0: dlum[i] = 0.0 else: dlum[i] = quadrature(ldist, 0, z[i])[0] if k > 0: dlum = np.sinh(np.sqrt(k)*dlum)/np.sqrt(k) elif k < 0: dlum = np.sin(np.sqrt(-k)*dlum)/np.sqrt(-k) result = c*(1+z)*dlum/H0 if len(result) == 1: return result[0] return result
def _evaluate(self,R,z,phi=0.,t=0.,dR=0,dphi=0):
"""
NAME:
_evaluate
PURPOSE:
evaluate the potential at R,z
INPUT:
R - Galactocentric cylindrical radius
z - vertical height
phi - azimuth
t - time
OUTPUT:
Phi(R,z)
HISTORY:
2010-07-09 - Started - Bovy (NYU)
"""
if dR == 0 and dphi == 0:
if not self.integerSelf == None:
return self.integerSelf._evaluate(R,z,phi=phi,t=t)
else:
r= numpy.sqrt(R**2.+z**2.)
return integrate.quadrature(_potIntegrandTransform,
0.,self.a/r,
args=(self.alpha,self.beta))[0]
elif dR == 1 and dphi == 0:
return -self._Rforce(R,z,phi=phi,t=t)
elif dR == 0 and dphi == 1:
return -self._phiforce(R,z,phi=phi,t=t)
def computeLuminosityDistance(z):
"""
Compute luminosity distance via gaussian quadrature.
@param z: Redshift at which to calculate luminosity distance
@return: Luminosity distance in Mpc
"""
# constants
H0 = 71 * 1000 # Hubble constant in (m/s)/Mpc
Ol = 0.73 # Omega lambda
Om = 0.27 # Omega matter
G = 6.67e-11 # Gravitational constant in SI units
c = 3.0e8 # Speed of light in SI units
# proper distance function
properDistance = lambda z: c/H0*np.sqrt(Ol+Om*(1+z)**3)
#def properDistance(z):
#
# Ez = np.sqrt(Ol+Om*(1+z)**3)
#
# return c/H0/Ez
# carry out numerical integration
Dp = si.quadrature(properDistance, 0 ,z)[0]
Dl = (1+z) * Dp
return Dl
def muBar_generic(self): """ Average inverse diffuse optical depth per unit leaf area calculated for an arbitrary G/GZ function """ out=integrate.quadrature( self.__muBar_generic_integ,0,1,vec_func=False) return out[0]
def kijko_sellevol_bayes(mag, mag_sig, bval, sigbval, tol = 1.0E-5,
maxiter = 1E3, obsmax=False):
'''Kijko-Sellevol-Bayes estimator of MMax and its associated uncertainty
(Eq. 12 - Kijko, 2004).
:param mag: Earthquake magnitudes
:type mag: numpy.ndarray
:param mag_sig: Earthquake Magnitude Uncertainty
:type mag_sig: numpy.ndarray
:param bval: b-value
:type bval: float
:param sigbval: b-value uncertainty
:type sigbval: float
:keyword tol: Intergral tolerance
:type tol: Float
:keyword maxiter: Maximum number of Iterations
:type maxiter: Int
:keyword obsmax: Maximum Observed Magnitude (if not in magnitude array)
and its corresponding uncertainty (sigma)
:type obsmax: Tuple (float) or Boolean
:return: **mmax** Maximum magnitude and **mmax_sig** corresponding
uncertainty
:rtype: Float
'''
if not(obsmax):
# If maxmag is False then maxmag is maximum from magnitude list
del(obsmax)
obsmax = np.max(mag)
obsmaxsig = mag_sig[np.argmax(mag)]
else:
obsmaxsig = obsmax[1]
obsmax = obsmax[0]
neq = np.float(np.shape(mag)[0])
mmin = np.min(mag)
mmax = np.copy(obsmax)
beta = bval * np.log(10.)
sigbeta = sigbval * np.log(10.)
pval = beta / (sigbeta ** 2.)
qval = (beta / sigbeta) ** 2.
d_t = 1.E8
j = 0
while d_t > tol:
rval = pval / (pval + mmax - mmin)
ldelt = (1. / (1. - (rval ** qval))) ** neq
delta = ldelt * quadrature(ksb_intfunc, mmin, mmax,
args = [neq, mmin, pval, qval])[0]
tmmax = obsmax + delta
d_t = np.abs(tmmax - mmax)
mmax = np.copy(tmmax)
j += 1
if j > maxiter:
print 'Kijko-Sellevol-Bayes estimator reached'
print 'maximum # of iterations'
d_t = 0.5 * tol
mmax_sig = np.sqrt(obsmaxsig ** 2. + delta ** 2.)
return mmax, mmax_sig
def main():
group_edges, sig_t, sig_el, scat_mat = proc_cx_file('hydrogen.cx')
group_dE = [group_edges[i] - group_edges[i+1] for i in range(len(group_edges)-1)]
#convert all cross sections to
atom_dens = 0.00149
sig_t = [i*atom_dens for i in sig_t]
for key in scat_mat.keys():
scat_mat[key] = [[i*atom_dens for i in x] for x in scat_mat[key]]
sig_el = [i*atom_dens for i in sig_el]
#Check
print "These two numbers should be equal", sum([scat_mat[0][i][4] for i in range(5)]), sig_el[4]
#create the fission spectrum for U235
chi = lambda E: 0.4865*np.sinh(np.sqrt(2.*E))*np.exp(-E)
#Find group averaged chi's
chi_groups = []
for i in range(len(group_edges)-1):
chi_g = quadrature(chi,group_edges[i+1],group_edges[i])[0]
chi_groups.append(chi_g)
chi_groups = np.array(chi_groups)
#Build a matrix
A = np.zeros((len(chi_groups),len(chi_groups)))
#Same matrix for all methods
S = scat_mat[0]
for i in range(len(A)):
A[i,i] = sig_t[i]
for j in range(len(A[i])):
A[i,j] -= S[i][j]
#Solve system
phi = np.linalg.solve(A,chi_groups)
#normalize
intphi = sum([group_dE[i]*phi[i] for i in range(len(phi))])
phi = [i/intphi for i in phi]
#let's make some plots
fig = plt.figure()
log_x = np.linspace(math.log10(group_edges[0]-0.000001),math.log10(group_edges[-1]),num=1000)
x = [10.**i for i in log_x]
y = []
for i in x:
for g in range(len(phi)):
if i <= group_edges[g]:
if i >= group_edges[g+1]:
y.append(phi[g])
print len(x), len(y)
plt.semilogx(x,y)
plt.legend(loc=3) #bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.ylabel("$\phi(E)/|\phi(E)|_1$ MeV$^{-1}$")
plt.xlabel("E (MeV)")
plt.savefig("../method_compare.pdf",bbox_inches='tight')
def angle3(self,**kwargs):
"""
NAME:
angle3 DONE
PURPOSE:
Calculate the radial angle
INPUT:
scipy.integrate.quadrature keywords
OUTPUT:
angle_3 in radians +
estimate of the error (does not include TR error)
HISTORY:
2011-03-03 - Written - Bovy (NYU)
"""
if hasattr(self,'_angle3'):
return self._angle3
(rperi,rap)= self.calcRapRperi()
if rap == rperi:
return 0.
T3= self.T3(**kwargs)[0]
EL= self.calcEL()
E, L= EL
Rmean= m.exp((m.log(rperi)+m.log(rap))/2.)
if self._r < Rmean:
if self._r > rperi:
wR= (2.*m.pi/T3*
nu.array(integrate.quadrature(_T3SphericalIntegrandSmall,
0.,m.sqrt(self._axi._R-rperi),
args=(E,L,self._pot,rperi),
**kwargs)))\
+nu.array([m.pi,0.])
else:
wR= nu.array([m.pi,0.])
else:
if self._r < rap:
wR= -(2.*m.pi/T3*
nu.array(integrate.quadrature(_TRAxiIntegrandLarge,
0.,m.sqrt(rap-self._axi._R),
args=(E,L,self._pot,rap),
**kwargs)))
else:
wR= nu.array([0.,0.])
if self._axi._vR < 0.:
wR[0]+= m.pi
self._angle3= nu.array([wR[0] % (2.*m.pi),wR[1]])
return self._angle3
def angleR(self,**kwargs): #pragma: no cover
"""
NAME:
AngleR
PURPOSE:
Calculate the radial angle
INPUT:
scipy.integrate.quadrature keywords
OUTPUT:
w_R(R,vT,vT) in radians +
estimate of the error (does not include TR error)
HISTORY:
2010-12-01 - Written - Bovy (NYU)
"""
if hasattr(self,'_angleR'):
return self._angleR
(rperi,rap)= self.calcRapRperi(**kwargs)
if rap == rperi:
return 0.
TR= self.TR(**kwargs)[0]
EL= self.calcEL(**kwargs)
E, L= EL
Rmean= m.exp((m.log(rperi)+m.log(rap))/2.)
if self._R < Rmean:
if self._R > rperi:
wR= (2.*m.pi/TR*
nu.array(integrate.quadrature(_TRAxiIntegrandSmall,
0.,m.sqrt(self._R-rperi),
args=(E,L,self._pot,rperi),
**kwargs)))\
+nu.array([m.pi,0.])
else:
wR= nu.array([m.pi,0.])
else:
if self._R < rap:
wR= -(2.*m.pi/TR*
nu.array(integrate.quadrature(_TRAxiIntegrandLarge,
0.,m.sqrt(rap-self._R),
args=(E,L,self._pot,rap),
**kwargs)))
else:
wR= nu.array([0.,0.])
if self._vR < 0.:
wR[0]+= m.pi
self._angleR= nu.array([wR[0] % (2.*m.pi),wR[1]])
return self._angleR
def E0_integrate(g):
f = lambda k: -1. / (2. * np.pi) * np.sqrt(g**2 - 2 * g * np.cos(k) + 1)
E0, error = integrate.quadrature(f,
-np.pi,
np.pi,
tol=1e-16,
rtol=1e-16,
maxiter=2000)
return E0, error
def idc_fe(self, a, b, alpha, N, p, f):
"""Perform IDCp-FE
Input: (a,b) endpoints; alpha ics; N #intervals; p order; f vector field.
Require: N divisible by M=p-1, with JM=N. M is #corrections.
Return: eta_sol
"""
# Initialise, J intervals of size M
if not type(N) is int:
raise TypeError('N must be integer')
M = p - 1
if N % M != 0:
raise Exception('p-1 does not divide N')
dt = (b - a) / N
J = int(N / M)
S = np.zeros([M, M + 1])
# M corrections, M intervals I, of size J
eta_sol = np.zeros(N + 1)
eta_sol[0] = alpha
eta = np.zeros([M + 1, J, M + 1])
t = np.zeros([J, M + 1])
eta_overlaps = np.zeros([J])
# Precompute integration matrix
for m in range(M):
for i in range(M + 1):
c = lambda t, i: reduce(lambda x, y: x * y, [(t - k) / (i - k)
for k in range(M)
if k != i])
S[m, i] = quadrature(c, m, m + 1, args=(i))[0]
for j in range(J):
# Prediction Loop
eta[0, j, 0] = alpha if j == 0 else eta_overlaps[j]
for m in range(M):
t[j, m] = (j * M + m) * dt
eta[0, j, m + 1] = eta[0, j, m] + dt * f(t[j, m], eta[0, j, m])
# Correction Loops
for l in range(1, M + 1):
eta[l, j, 0] = eta[l - 1, j, 0]
for m in range(M):
# Error equation, Forward Euler
term1 = dt * (f(t[j, m], eta[l, j, m]) -
f(t[j, m], eta[l - 1, j, m]))
term2 = dt * np.sum([
S[m, i] * f(t[j, i], eta[l - 1, j, i])
for i in range(M)
])
eta[l, j, m + 1] = eta[l, j, m] + term1 + term2
eta_sol[j * M + 1:(j + 1) * M + 1] = eta[M, j, 1:]
if j != J - 1:
eta_overlaps[j + 1] = eta[M, j, M]
return np.arange(a, b + dt, dt)[:-1], eta_sol[:-1]
def test_quadrature_miniter(self):
# Typical function with two extra arguments:
def myfunc(x,n,z): # Bessel function integrand
return cos(n*x-z*sin(x))/pi
table_val = 0.30614353532540296487
for miniter in [5, 52]:
val, err = quadrature(myfunc,0,pi,(2,1.8),miniter=miniter)
assert_almost_equal(val, table_val, decimal=7)
assert_(err < 1.0)
def fmin(gamma, measpcfc, cfcinterp, tmax):
# This is the function to be minimized: the difference between the observed partial
# pressure and that done by convolving an IG with the atmospheric history
conv, _ = quadrature(pdf_atm_expr,
0,
tmax,
args=(gamma, cfcinterp),
tol=0.1)
return np.sqrt((measpcfc - conv)**2)
def TRFlat(R, vR, vT, vc=1., ro=1., rap=None, rperi=None, **kwargs):
"""
NAME:
TRFlat
PURPOSE:
Calculate the radial period for a flat rotation curve
INPUT:
R - Galactocentric radius (/ro)
vR - radial part of the velocity (/vc)
vT - azimuthal part of the velocity (/vc)
vc - circular velocity
ro - reference radius
+scipy.integrate.quadrature keywords
OPTIONAL INPUT:
rap - apocenter radius (/ro)
rperi - pericenter radius (/ro)
OUTPUT:
T_R(R,vT,vT)*vc/ro + estimate of the error
HISTORY:
2010-05-13 - Written - Bovy (NYU)
"""
if rap == None or rperi == None:
(rperi, rap) = calcRapRperiFlat(R, vR, vT, vc=vc, ro=ro)
if rap == rperi: #Rough limit
e = 10.**-6.
rap = R * (1 + e)
rperi = R * (1 - e)
Rmean = m.exp((m.log(rperi) + m.log(rap)) / 2.)
TR = 0.
if Rmean > rperi:
TR += rperi * nu.array(
integrate.quadrature(_TRFlatIntegrandSmall,
0.,
m.sqrt(Rmean / rperi - 1.),
args=((R * vT)**2 / rperi**2., ),
**kwargs))
if Rmean < rap:
TR += rap * nu.array(
integrate.quadrature(_TRFlatIntegrandLarge,
0.,
m.sqrt(1. - Rmean / rap),
args=((R * vT)**2 / rap**2., ),
**kwargs))
return m.sqrt(2.) * TR
def test_pdf_boundary_quadrature(self): for bw in [1e-2, 1e-1, 1]: hp_kernel = hp_kernels.Gaussian(data=self.x_train, bandwidth=bw, fix_boundary=True) def quad_me(x): x_test = np.array([x]) pdfs = hp_kernel(x_test) return(pdfs.mean()) self.assertAlmostEqual(quadrature(quad_me, 0, 1)[0], 1, delta=1e-4)
def muBar_generic(self):
"""
Average inverse diffuse optical depth per unit leaf area
calculated for an arbitrary G/GZ function
"""
out = integrate.quadrature(self.__muBar_generic_integ,
0,
1,
vec_func=False)
return out[0]
def _intensity(self):
"""
Returns an array of the integrated values using ~scipy.integrate.quadrature as the
intensities for the blue shifted and red shifted rays above the critical impact paratmeter
from the distance to the emitter
"""
intensity = []
for i in np.arange(len(self.z)):
b = self.z[i][0]
val1, _ = quadrature(self._intensity_blue_sch,
self.fov.value,
self.z[i][1],
args=(b, ))
val2, _ = quadrature(self._intensity_red_sch,
self.z[i][1],
self.fov.value,
args=(b, ))
intensity.append(val1 + val2)
return intensity
def I(self, **kwargs):
"""
NAME:
I
PURPOSE:
Calculate I, the 'ratio' between the radial and azimutha period,
for a flat rotation curve
INPUT:
+scipy.integrate.quadrature keywords
OUTPUT:
I(R,vT,vT) + estimate of the error
HISTORY:
2010-05-13 - Written - Bovy (NYU)
"""
if hasattr(self, '_I'):
return self._I
(rperi, rap) = self.calcRapRperi()
Rmean = m.exp((m.log(rperi) + m.log(rap)) / 2.)
if rap == rperi: #Rough limit
TR = self.TR()[0]
Tphi = self.Tphi()[0]
self._I = nu.array([TR / Tphi, 0.])
return self._I
I = 0.
if Rmean > rperi:
I += nu.array(
integrate.quadrature(
_IFlatIntegrandSmall,
0.,
m.sqrt(Rmean / rperi - 1.),
args=((self._R * self._vT)**2 / rperi**2., ),
**kwargs)) / rperi
if Rmean < rap:
I += nu.array(
integrate.quadrature(_IFlatIntegrandLarge,
0.,
m.sqrt(1. - Rmean / rap),
args=(
(self._R * self._vT)**2 / rap**2., ),
**kwargs)) / rap
self._I = I / m.sqrt(2.) * self._R * self._vT
return self._I
def prob_damage_states(damfun, poecurve):
pds = {}
for ds in damfun.ds:
pgas, poes = zip(*poecurve)
paddedpgas = [0] + list(pgas) + [3]
paddedpoes = [1] + list(poes) + [0]
poef = interp1d(paddedpgas, paddedpoes)
kernel = lambda x: damfun(ds, x) * (1 - poef(x))
pds[ds] = 1 - quadrature(kernel, 0, 3)[0]
return pds
def TR(self, **kwargs):
"""
NAME:
TR
PURPOSE:
Calculate the radial period for a flat rotation curve
INPUT:
scipy.integrate.quadrature keywords
OUTPUT:
T_R(R,vT,vT)*vc/ro + estimate of the error
HISTORY:
2010-05-13 - Written - Bovy (NYU)
"""
if hasattr(self, '_TR'):
return self._TR
(rperi, rap) = self.calcRapRperi()
if rap == rperi: #Rough limit
#TR=kappa
kappa = m.sqrt(2.) / self._R
self._TR = nu.array([2. * m.pi / kappa, 0.])
return self._TR
Rmean = m.exp((m.log(rperi) + m.log(rap)) / 2.)
TR = 0.
if Rmean > rperi:
TR += rperi * nu.array(
integrate.quadrature(
_TRFlatIntegrandSmall,
0.,
m.sqrt(Rmean / rperi - 1.),
args=((self._R * self._vT)**2 / rperi**2., ),
**kwargs))
if Rmean < rap:
TR += rap * nu.array(
integrate.quadrature(_TRFlatIntegrandLarge,
0.,
m.sqrt(1. - Rmean / rap),
args=(
(self._R * self._vT)**2 / rap**2., ),
**kwargs))
self._TR = m.sqrt(2.) * TR
return self._TR
def predictive_intensity_function(self, X_eval):
""" Computes the predictive intensity function at X_eval by Gaussian
quadrature.
:param X_eval: numpy.ndarray [num_points_eval x D]
Points where the intensity function should be evaluated.
:returns:
numpy.ndarray [num_points]: mean of predictive posterior intensity
numpy.ndarray [num_points]: variance of predictive posterior
intensity
"""
num_preds = X_eval.shape[0]
mu_pred, var_pred = self.predictive_posterior_GP(X_eval)
mean_lmbda_pred, var_lmbda_pred = numpy.empty(num_preds), \
numpy.empty(num_preds)
mean_lmbda_q1 = self.lmbda_star_q1
var_lmbda_q1 = self.alpha_q1 / (self.beta_q1**2)
mean_lmbda_q1_squared = var_lmbda_q1 + mean_lmbda_q1**2
for ipred in range(num_preds):
mu, std = mu_pred[ipred], numpy.sqrt(var_pred[ipred])
func1 = lambda g_pred: 1. / (1. + numpy.exp(-g_pred)) * \
numpy.exp(-.5*(g_pred - mu)**2 / std**2) / \
numpy.sqrt(2.*numpy.pi*std**2)
a, b = mu - 10. * std, mu + 10. * std
mean_lmbda_pred[ipred] = mean_lmbda_q1 * quadrature(
func1, a, b, maxiter=500)[0]
func2 = lambda g_pred: (1. / (1. + numpy.exp(-g_pred)))**2 * \
numpy.exp(
-.5 * (g_pred - mu) ** 2 / std ** 2) / \
numpy.sqrt(2. * numpy.pi * std ** 2)
a, b = mu - 10. * std, mu + 10. * std
mean_lmbda_pred_squared = mean_lmbda_q1_squared *\
quadrature(func2, a, b, maxiter=500)[0]
var_lmbda_pred[
ipred] = mean_lmbda_pred_squared - mean_lmbda_pred[ipred]**2
return mean_lmbda_pred, var_lmbda_pred
def ip_08_04():
"""
MATLAB script for Illustrative Problem 4, Chapter 8.
"""
a_db = np.arange(-13, 13.5, 0.5)
a = 10**(a_db / 10)
a_hard = a.copy()
c_hard = 1 - entropy2(qfunc(a_hard))
f = np.zeros(53)
g = np.zeros(53)
c_soft = np.zeros(53)
il3_8fun = lambda x, p: 1 / np.sqrt(2 * np.pi) * np.exp(
(-(x - p)**2) / 2) * np.log2(2 / (1 + np.exp(-2 * x * p)))
for i in range(0, 53):
f[i] = integrate.quadrature(il3_8fun,
a[i] - 5,
a[i] + 5,
args=(a[i], ),
tol=1e-3)[0] # ,1e-3,[],a[i]
g[i] = integrate.quadrature(il3_8fun,
-a[i] - 5,
-a[i] + 5,
args=(-a[i], ),
tol=1e-3)[0] # ,1e-3
c_soft[i] = 0.5 * f[i] + 0.5 * g[i]
plt.title(
'Capacity for BPSK transmisison on the AWGN channel for Hard and Soft Decision'
)
plt.xlabel(r'A/$\sigma$')
plt.ylabel('Capacity in bits Per channel Use')
# plt.grid(True,which="both",ls="-")
line1, = plt.semilogx(a, c_soft, label="Soft Decision")
line2, = plt.semilogx(a_hard, c_hard, label="Hard Decision")
plt.legend(handles=[
line1,
line2,
], loc=4)
plt.show()
return
def angle2(self,**kwargs):
"""
NAME:
angle2 DONE
PURPOSE:
Calculate the longitude of the ascending node
INPUT:
OUTPUT:
angle2 in radians +
estimate of the error
HISTORY:
2011-03-03 - Written - Bovy (NYU)
"""
if hasattr(self,'_angle2'): return self._angle2
if not hasattr(self,'_i'): self._i= m.acos(self._J1/self._J2)
if self._i == 0.: dstdj2= m.pi/2.
else: dstdj2= m.asin(m.cos(self._theta)/m.sin(self._i))
out= self._angle3(**kwargs)*self.T3(**kwargs)[0]/self.T2(**kwargs)[0]
out[0]+= dstdj2
#Now add the final piece dsrdj2
EL= self.calcEL()
E, L= EL
Rmean= m.exp((m.log(rperi)+m.log(rap))/2.)
if self._axi._R < Rmean:
if self._axi._R > self.rperi:
out+= L*nu.array(integrate.quadrature(_ISphericalIntegrandSmall,
0.,m.sqrt(self._axi._R-rperi),
args=(E,L,self._pot,rperi),
**kwargs))
else:
if self._axi._R < self._rap:
out+= L*nu.array(integrate.quadrature(_ISphericalIntegrandLarge,
0.,m.sqrt(rap-self._axi._R),
args=(E,L,self._pot,rap),
**kwargs))
else:
out[0]+= m.pi*self.T3(**kwargs)[0]/self.T2(**kwargs)[0]
if self._axi._vR < 0.:
out[0]+= m.pi*self.T3(**kwargs)[0]/self.T2(**kwargs)[0]
self._angle2= out
return self._angle2
def outer_integrand(y):
return sint.quadrature( # NOQA
lambda x: func(x, y, *args),
a,
b,
(),
toli,
rtoli,
maxiteri,
vec_func,
miniteri,
)[0] # NOQA
def z_to_cdist(z):
''' Calculate the comoving distance
Parameters:
z (float): redshift
Returns:
Comoving distance in Mpc
'''
Ez_func = lambda x: 1./np.sqrt(const.Omega0*(1.+x)**3+const.lam)
dist = const.c/const.H0 * quadrature(Ez_func, 0, z)[0]
return outputify(dist)
def volssa_generic(self):
"""
The volume single scattering albedo for any
G and Zeta function
See eqn 5 & 7 of Sellers 1985
"""
out = integrate.quadrature(self.__volssa_generic_integ,
0,
1,
vec_func=False)
return out[0] * (self.leaf_r + self.leaf_t) * 0.5
def compute_ext_inf_integral(target, s, radius):
# target: target point
# s: fractional order
# radius: radius of the circle
import scipy.integrate as sint
val, _ = sint.quadrature(partial(ext_inf_integrand,
s=s,
target=target,
radius=radius),
a=0,
b=2 * np.pi)
return val * (1 / (2 * s)) * fl_scaling(k=self.dim, s=s)
def traveltime(x, c):
"""
Calculates the travel-time
Args:
x: scalar or array of locations
c: Velocity model; has to be a callable function returning the velocity at some location
"""
from scipy.integrate import quadrature
from numpy import isscalar, asarray, empty
s = lambda x: 1.0 / c(x)
if isscalar(x):
T = quadrature(func=s, a=0.0, b=x)[0]
else:
x = asarray(x)
T = empty(x.shape)
T[:] = [quadrature(func=s, a=0.0, b=b)[0] for b in x]
return T
def MutalInductance(r1, r2, d):
# return 0.5 * mu0 * quadrature(_f, 0, 2*nu.pi, args=(r1, r2, d), tol=1e-9, maxiter=100000)[0]
# return 0.5 * mu0 * quadrature(_g, -1, 1, args=(r1, r2, d), tol=1e-12, maxiter=100000)[0]
k = nu.sqrt(4 * r1 * r2 / ((r1 + r2)**2 + d**2))
result = mu0 * nu.sqrt(r1 * r2) * (
(2 / k - k) * ellipk(k**2) - 2 / k * ellipe(k**2))
if result >= 0:
return result
else:
return 0.5 * mu0 * quadrature(
_f, 0, 2 * nu.pi, args=(r1, r2, d), tol=1e-6, maxiter=3000)[0]
def xi_poles(rfid, alpha, epsilon, order):
coeff = 2 * order + 1
fn = xi_poles_integrand
int, error = quadrature(fn,
0,
1,
tol=1.49e-8,
maxiter=100,
args=(rfid, alpha, epsilon, order),
vec_func=False)
return coeff * int
def TR(self, **kwargs):
"""
NAME:
TR
PURPOSE:
Calculate the radial period for a power-law rotation curve
INPUT:
scipy.integrate.quadrature keywords
OUTPUT:
T_R(R,vT,vT)*vc/ro + estimate of the error
HISTORY:
2010-11-30 - Written - Bovy (NYU)
"""
if hasattr(self, '_TR'):
return self._TR
(rperi, rap) = self.calcRapRperi()
if rap == rperi: #Rough limit
#TR=kappa
gamma = m.sqrt(2. / (1. + self._beta))
kappa = 2. * self._R**(self._beta - 1.) / gamma
self._TR = nu.array([2. * m.pi / kappa, 0.])
return self._TR
Rmean = m.exp((m.log(rperi) + m.log(rap)) / 2.)
TR = 0.
if Rmean > rperi:
TR+= rperi**(1.-self._beta)\
*nu.array(integrate.quadrature(_TRPowerIntegrandSmall,
0.,m.sqrt(Rmean/rperi-1.),
args=(self._X,self._beta,
self._signbeta),
**kwargs))
if Rmean < rap:
TR+= rap**(1.-self._beta)\
*nu.array(integrate.quadrature(_TRPowerIntegrandLarge,
0.,m.sqrt(1.-Rmean/rap),
args=(self._Y,self._beta,
self._signbeta),
**kwargs))
self._TR = 2. * m.sqrt(self._absbeta) * TR
return self._TR
def I(self, **kwargs):
"""
NAME:
I
PURPOSE:
Calculate I, the 'ratio' between the radial and azimutha period,
for a power-law rotation curve
INPUT:
+scipy.integrate.quadrature keywords
OUTPUT:
I(R,vT,vT) + estimate of the error
HISTORY:
2010-11-30 - Written - Bovy (NYU)
"""
if hasattr(self, '_I'):
return self._I
(rperi, rap) = self.calcRapRperi()
Rmean = m.exp((m.log(rperi) + m.log(rap)) / 2.)
if rap == rperi: #Rough limit
TR = self.TR()[0]
Tphi = self.Tphi()[0]
self._I = nu.array([TR / Tphi, 0.])
return self._I
I = 0.
if Rmean > rperi:
I+= rperi**(-1.-self._beta)\
*nu.array(integrate.quadrature(_IPowerIntegrandSmall,
0.,m.sqrt(Rmean/rperi-1.),
args=(self._X,self._beta,
self._signbeta),
**kwargs))
if Rmean < rap:
I+= rap**(-1.-self._beta)\
*nu.array(integrate.quadrature(_IPowerIntegrandLarge,
0.,m.sqrt(1.-Rmean/rap),
args=(self._Y,self._beta,
self._signbeta),
**kwargs))
self._I = I * self._R * self._vT * m.sqrt(self._absbeta)
return self._I
def _calc_angler(self, Or, r, Rmean, rperi, rap, E, L, vr, fixed_quad,
**kwargs):
if r < Rmean:
if r > rperi and not fixed_quad:
wr = Or * integrate.quadrature(_TrSphericalIntegrandSmall,
0.,
m.sqrt(r - rperi),
args=(E, L, self._2dpot, rperi),
**kwargs)[0]
elif r > rperi and fixed_quad:
wr = Or * integrate.fixed_quad(_TrSphericalIntegrandSmall,
0.,
m.sqrt(r - rperi),
args=(E, L, self._2dpot, rperi),
n=10,
**kwargs)[0]
else:
wr = 0.
if vr < 0.: wr = 2 * m.pi - wr
else:
if r < rap and not fixed_quad:
wr = Or * integrate.quadrature(_TrSphericalIntegrandLarge,
0.,
m.sqrt(rap - r),
args=(E, L, self._2dpot, rap),
**kwargs)[0]
elif r < rap and fixed_quad:
wr = Or * integrate.fixed_quad(_TrSphericalIntegrandLarge,
0.,
m.sqrt(rap - r),
args=(E, L, self._2dpot, rap),
n=10,
**kwargs)[0]
else:
wr = m.pi
if vr < 0.:
wr = m.pi + wr
else:
wr = m.pi - wr
return wr
def TR(self,**kwargs):
"""
NAME:
TR
PURPOSE:
Calculate the radial period for a power-law rotation curve
INPUT:
scipy.integrate.quadrature keywords
OUTPUT:
T_R(R,vT,vT)*vc/ro + estimate of the error
HISTORY:
2010-12-01 - Written - Bovy (NYU)
"""
if hasattr(self,'_TR'):
return self._TR
(rperi,rap)= self.calcRapRperi(**kwargs)
if rap == rperi: #Rough limit
raise AttributeError("Not implemented yet")
#TR=kappa
gamma= m.sqrt(2./(1.+self._beta))
kappa= 2.*self._R**(self._beta-1.)/gamma
self._TR= nu.array([2.*m.pi/kappa,0.])
return self._TR
Rmean= m.exp((m.log(rperi)+m.log(rap))/2.)
EL= self.calcEL(**kwargs)
E, L= EL
TR= 0.
if Rmean > rperi:
TR+= nu.array(integrate.quadrature(_TRAxiIntegrandSmall,
0.,m.sqrt(Rmean-rperi),
args=(E,L,self._pot,rperi),
**kwargs))
if Rmean < rap:
TR+= nu.array(integrate.quadrature(_TRAxiIntegrandLarge,
0.,m.sqrt(rap-Rmean),
args=(E,L,self._pot,rap),
**kwargs))
self._TR= 2.*TR
return self._TR
def calcularDensidadeEnergia(nQuarks, sacola, massa):
resultado = 0
eAuxiliar = 0
e = []
for kf in range(1, 1001):
for i in range(0, nQuarks):
resultado = integrate.quadrature(
lambda k: (k**2) * (((k**2) + (massa[i]**2))**(1 / 2)), 0, kf)
eAuxiliar += resultado[0]
e.append((6 / ((2 * pi)**2)) * eAuxiliar + sacola)
resultado = 0
eAuxiliar = 0
return e
def calcularPressao(nQuarks, sacola, massa):
resultado = 0
pAuxiliar = 0
p = []
for kf in range(1, 1001):
for i in range(0, nQuarks):
resultado = integrate.quadrature(
lambda k: (k**4) / (((k**2) + (massa[i]**2))**(1 / 2)), 0, kf)
pAuxiliar += resultado[0]
p.append((1 / (pi**2)) * pAuxiliar - sacola)
resultado = 0
pAuxiliar = 0
return p
def T3(self,**kwargs):
"""
NAME:
T3 DONE
PURPOSE:
Calculate the radial period
INPUT:
scipy.integrate.quadrature keywords
OUTPUT:
T_3(R,vT,vT)*vc/ro + estimate of the error
HISTORY:
2011-03-03 - Written - Bovy (NYU)
"""
if hasattr(self,'_T3'):
return self._T3
(rperi,rap)= self.calcRapRperi()
if rap == rperi: #Rough limit
raise AttributeError("Not implemented yet")
#TR=kappa
gamma= m.sqrt(2./(1.+self._beta))
kappa= 2.*self._R**(self._beta-1.)/gamma
self._TR= nu.array([2.*m.pi/kappa,0.])
return self._TR
Rmean= m.exp((m.log(rperi)+m.log(rap))/2.)
EL= self.calcEL()
E, L= EL
T3= 0.
if Rmean > rperi:
T3+= nu.array(integrate.quadrature(_T3SphericalIntegrandSmall,
0.,m.sqrt(Rmean-rperi),
args=(E,L,self._pot,rperi),
**kwargs))
if Rmean < rap:
T3+= nu.array(integrate.quadrature(_T3SphericalAxiIntegrandLarge,
0.,m.sqrt(rap-Rmean),
args=(E,L,self._pot,rap),
**kwargs))
self._T3= 2.*T3
return m.fabs(self._T3)
def complex_quadrature(integrand: Callable, a: float, b: float,
**kwargs) -> Tuple[complex, tuple, tuple]:
"""
As :func:`scipy.integrate.quadrature`, but works with complex integrands.
Parameters
----------
integrand
The function to integrate.
a
The lower limit of integration.
b
The upper limit of integration.
kwargs
Additional keyword arguments are passed to
:func:`scipy.integrate.quadrature`.
Returns
-------
(result, real_extras, imag_extras)
A tuple containing the result, as well as the other things returned
by :func:`scipy.integrate.quadrature` for the real and imaginary parts
separately.
"""
def real_func(*args, **kwargs):
return np.real(integrand(*args, **kwargs))
def imag_func(*args, **kwargs):
return np.imag(integrand(*args, **kwargs))
real_integral = integ.quadrature(real_func, a, b, **kwargs)
imag_integral = integ.quadrature(imag_func, a, b, **kwargs)
return (
real_integral[0] + (1j * imag_integral[0]),
real_integral[1:],
imag_integral[1:],
)
def p_avg(p0, a1, a3, Ex, T, tol=1.0e-3, maxiter=50):
args = (p0, a1, a3, Ex, T)
norm, error_norm = quadrature(kernel,
0,
pi,
args=args,
tol=tol,
maxiter=maxiter)
cos_avg, error_cos = quadrature(func_cos_avg,
0,
pi,
args=args,
tol=tol,
maxiter=maxiter)
cos_square_avg, error_cos_sqr = quadrature(func_cos_sqr_avg,
0,
pi,
args=args,
tol=tol,
maxiter=maxiter)
cos_avg *= 1.0 / norm
cos_square_avg *= 1.0 / norm
return p0 * cos_avg + (a1 + (a3 - a1) * cos_square_avg) * Ex
