def f(Jm, Jn, r, i, J, M, LRules, rulesX, rulesW, nu, k):
sum2 = 0
Jn1 = J[:, r]
Jm1 = J[:, i]
prod = 1.0
for o in range(0, M):
sumparc = 0
for l in range(0, LRules):
x1 = rulesX[l]
factor1 = (1.0 / sqrt(factorial(int(Jn1[o])))) * (
1.0 / sqrt(factorial(int(Jm1[o]))))
prod1 = special.eval_hermitenorm(int(
Jn1[o]), x1) * special.eval_hermitenorm(
int(Jm1[o]), x1) * factor1
sumparc = sumparc + prod1 * rulesW[l] / (sqrt(2.0 * nu) *
pi * (o + 1))
prod = prod * sumparc
for l in range(0, LRules):
x2 = rulesX[l]
factor2 = (1.0 / sqrt(factorial(int(Jn[k]) - 1))) * (
1.0 / sqrt(factorial(int(Jm[k]))))
sum2 = sum2 + special.eval_hermitenorm(
int(Jn[k]) - 1, x2) * special.eval_hermitenorm(
int(Jm[k]), x2) * rulesW[l] * factor2
return sum2 * prod
def integr1(self):
"""
Function to calculate first type of integrals.
Parameters
----------
J : array; shape([M, M])
Array containing the grades of the polynomials
M : int; max order polynomials
rulesX : array; polynomials of Hermite evaluated
rulesW : array; weights of polynomials of Hermite evaluated
LRules : array; length of rulesX array
nu : float; Diffusion coefficient
u0 : callable(x); initial condition function
Returns
-------
intg : float, value of first type of integral
"""
intg = 0
for k in range(0, self.LRules):
prod = 1
for i in range(0, self.M):
if self.J[i, 0] > 0:
prod = prod * special.eval_hermitenorm(
int(self.J[i, 0]), self.rulesX[k])
intg = intg + prod * self.rulesW[k]
return intg
def calc_a(self, multindices):
"""
This method builds the matrix containing the basis functions evaluated
at sample locations, i.e. the matrix A in Au = b
Parameters
----------
multindices : list
the list with the multi-indices
Returns
-------
A : array
the matrix with the evaluated basis functions for the samples
"""
dimension = self.my_experiment.dimension
x_u_scaled = self.my_experiment.x_u_scaled
a_matrix = np.ones([self.my_experiment.size, len(multindices)])
# generate the A matrix
for i, multiindex in enumerate(multindices):
for j in range(dimension):
deg = multiindex[j]
if self.my_experiment.polytypes[j] == 'Legendre':
a_matrix[:, i] *= special.eval_legendre(
deg, x_u_scaled[:, j])
elif self.my_experiment.polytypes[j] == 'Hermite':
a_matrix[:, i] *= special.eval_hermitenorm(
deg, x_u_scaled[:, j])
return a_matrix
def hermite_function(indices, x, t=-1):
output = 1
unique_indices = set(indices)
for i in unique_indices:
order = indices.count(i)
output *= eval_hermitenorm(order, x[t - i])
return output
def integ(xSpace, M, J):
Px = len(xSpace)
H = np.zeros([M, Px])
for k in range(0, Px):
for j in range(1, M):
prod = 1.0
for i in range(0, M):
if J[i, j] > 0:
x1 = integrate.quad(f, 0, 1, args=[k])[0]
prod = prod * special.eval_hermitenorm(
int(J[i, j]),
x1) * (1.0 / sqrt(factorial(J[i, j])))
H[j, k] = prod
x2 = xSpace[k]
H[0, k] = special.eval_hermitenorm(
2, x2) - special.eval_hermitenorm(1, x2) + 1
return H
def grad(self, x, order):
""" Return the first derivate of hermite polynomial evaluated at x
Args:
x (double) - evaulation point
order (int) - order of polynomial
Returns:
H_x (double)
"""
return order * eval_hermitenorm(order - 1, x)
def fun(self, x, order):
""" Return the hermite polynomial evaluated at x
Args:
x (double) - evaulation point
order (int) - order of polynomial
Returns:
H_x (double)
"""
return eval_hermitenorm(order, x)
def test_reduction_to_probabilist_polys():
"""Tests that the multidimensional hermite polynomials reduce to the regular probabilist' hermite polynomials in the appropriate limit"""
x = np.arange(-1, 1, 0.1)
init = 1
n_max = 5
A = np.ones([init, init], dtype=complex)
vals = np.array(
[hermite_multidimensional(A, n_max, y=np.array([x0], dtype=complex)) for x0 in x]
).T
expected = np.array([eval_hermitenorm(i, x) for i in range(len(vals))])
assert np.allclose(vals, expected)
def SimulaX(self):
"""
Function to simulate X.
Parameters
----------
J : array; shape([M, M])
Array containing the grades of the polynomials
M : int; number of ODEs
xSpace : array; discretized real space
nu : array; Diffusion coefficient
u0 : callable(x); initial condition function
Returns
-------
H : array, shape(M, len(xSpace))
Array containing hermite polynomials evaluated to simulate real space
"""
def evalXSin(x, k):
return sqrt(2.0 * self.nu) * k * pi * sqrt(
2.0 / pi) * (self.u0(x)) * (sin(k * pi * x))
Px = len(self.x)
H = np.zeros([self.M, Px])
for k in range(0, Px):
for j in range(1, self.M):
prod = 1.0
for i in range(0, self.M):
if self.J[i, j] > 0:
x1 = integrate.quad(evalXSin, 0, 1, args=k)[0]
prod = prod * special.eval_hermitenorm(
int(self.J[i, j]),
x1) * (1.0 / sqrt(factorial(self.J[i, j])))
H[j, k] = prod
x2 = self.x[k]
H[0,
k] = special.eval_hermitenorm(2, x2) - special.eval_hermitenorm(
1, x2) + 1
return H
def evaluate(self, x):
x = np.array(x).flatten()
# normalize data
x_normed = Polynomials.standardize_normal(
x,
mean=self.distributions.parameters['loc'],
std=self.distributions.parameters['scale'])
# evaluate standard Hermite polynomial, orthogonal w.r.t. the PDF of N(0,1)
h = eval_hermitenorm(self.degree, x_normed)
# normalization constant
st_herm_norm = np.sqrt(math.factorial(self.degree))
h = h / st_herm_norm
return h
def constants(xSpace, M, J, rulesX, rulesW, nu):
Lx = len(xSpace)
ci = np.zeros([M, Lx])
for z in range(0, Lx):
for i in range(0, M):
sum2 = 0
for k in range(0, M):
sum1 = 0
if J[k, i] > 0:
for y in range(0, self.LRules):
sum1 = sum1 + special.eval_hermitenorm(
int(J[k, i]),
rulesX[y]) * rulesX[y] * rulesW[y]
sum2 = sum2 + sum1 * f(
xSpace[z]) * sqrt(2.0) / (sqrt(2.0 * nu) * pi *
(k + 1))
ci[i, z] = sum2
return ci
def u02(self):
"""
Function to calculate the constants of the system of ordinary differential equations given the initial condition
Parameters
----------
J : array; shape(M, M)
Array containing the grades of the polynomials
N : int; order max of the polynomials
M : int; number of ODEs
rulesX : array; polynomials of Hermite evaluated
rulesW : array; weights of polynomials of Hermite evaluated
LRules : array; length of rulesX array
xSpace : array; discretized real space
nu : array; Diffusion coefficient
u0 : callable(x); initial condition function
Returns
-------
ci: array, shape(M, len(xSpace))
Array containing the constants of the system of ordinary differential equations
"""
Lx = len(self.x)
ci = np.zeros([self.M, Lx])
for z in range(0, Lx):
for i in range(0, self.M):
sum2 = 0
for k in range(0, self.M):
sum1 = 0
if self.J[k, i] > 0:
for y in range(0, self.LRules):
sum1 = sum1 + special.eval_hermitenorm(
int(self.J[k, i]), self.rulesX[y]
) * self.rulesX[y] * self.rulesW[y]
sum2 = sum2 + sum1 * self.u0(
self.x[z]) * sqrt(2.0) / (sqrt(2.0 * self.nu) * pi *
(k + 1))
ci[i, z] = sum2
return ci
def gen(n, x, name):
"""Generate fixture data and write to file.
# Arguments
* `n`: degree(s)
* `x`: domain
* `name::str`: output filename
# Examples
``` python
python> n = 1
python> x = linspace(-1000, 1000, 2001)
python> gen(n, x, './data.json')
```
"""
y = eval_hermitenorm(n, x)
if isinstance(n, np.ndarray):
data = {
"n": n.tolist(),
"x": x.tolist(),
"expected": y.tolist()
}
else:
data = {
"n": n,
"x": x.tolist(),
"expected": y.tolist()
}
# Based on the script directory, create an output filepath:
filepath = os.path.join(DIR, name)
# Write the data to the output filepath as JSON:
with open(filepath, "w") as outfile:
json.dump(data, outfile)
def pdf4(phi, a, m=4, verbose=False): ''' This implementation expands the posterior distribution in terms of the standard normal distribution using the Gram-Charlier series (http://en.wikipedia.org/wiki/Edgeworth_series). This series generally doesn't converge, but can be really fast. Generally, don't use more than four or five terms (m=4). This makes the distribution accurate to the fourth moment, the kurtosis and is much better than using a normal distribution (which is the first two moments). Actually, just use pdf3. References: https://indico.cern.ch/event/74919/session/16/contribution/88/material/slides/1.pdf ''' sigma = math.sqrt(b_l(2,a)) mu = b_l(1,a) z = (phi - mu)/sigma C = [1.,-1.,-1.,1.] normpart = stats.norm.pdf(phi, loc=mu, scale=sigma) seriespart = [ b_l(k,a)/(math.factorial(k) * sigma**(k) ) * special.eval_hermitenorm(k, z)[0] for k in range(3,m+1) ] return normpart * (1 + np.sum(seriespart))
def f1(x, y, Jij):
return abs((-1)**Jij * (special.eval_hermitenorm(Jij, x) -
special.eval_hermitenorm(Jij, y)) /
factorial(Jij + 1)**2)**2
def m2fs_ghlb_profile(fname, tracefname, tracestdfname, fibermapfname,
x_begin, x_end,
dy=5, legorder=6, ghorder=10,
make_plot=True, suffix=""):
""" Use the same dy as in m2fs_trace_orders """
Nleg = legorder + 1
Ngh = ghorder + 1
outdir = os.path.dirname(fname)
outname = os.path.basename(fname)[:-5]+suffix
fname_fitparams = os.path.join(outdir,outname+"_ghlb_fitparams.txt")
fname_allyarr = os.path.join(outdir,outname+"_ghlb_yarr.npy")
fname_alldatarr = os.path.join(outdir,outname+"_ghlb_data.npy")
fname_allerrarr = os.path.join(outdir,outname+"_ghlb_errs.npy")
fname_allprofiles = os.path.join(outdir,outname+"_ghlb_profiles.npy")
Nparam=Nleg*Ngh
data, edata, header = read_fits_two(fname)
nx, ny = data.shape
coeffcen = np.loadtxt(tracefname)
coeffstd = np.loadtxt(tracestdfname)
fibmap = np.loadtxt(fibermapfname)
npeak, norder = len(coeffcen), fibmap.shape[1]
# Generate valid pixels: could do this in a more refined way
xarrlist = [np.arange(nx) for i in range(norder)]
xarrlist[0] = np.arange(nx-x_begin)+x_begin
xarrlist[-1] = np.arange(x_end)
## SECOND TRACE:
# For each order, fit spatial profile to the full trace simultaneously
# Following Kelson ghlb.pdf
# But fitting each fiber separately in some specified extraction region
# rather than solving for the distortion functions
# Go 1 pixel further on each side, ensure an odd number
Nextract = int(dy)+4 + int(int(dy) % 2 == 0)
dextract = int(Nextract/2.)
vround = np.vectorize(lambda x: int(round(x)))
start = time.time()
# Outputs
allyarr = np.zeros((npeak,Nextract,nx))
fitparams = np.zeros((npeak,Nleg*Ngh))
alldatarr = np.full((npeak,nx,Nextract), np.nan)
allerrarr = np.full((npeak,nx,Nextract), np.nan)
allfitarr = np.full((npeak,nx,Nextract), np.nan)
for ipeak in range(npeak):
# Initialize peak locations, widths, and data arrays
xarr = xarrlist[ipeak % norder]
Nxarr = len(xarr)
Nxy = Nxarr*Nextract
ypeak = np.polyval(coeffcen[ipeak],xarr)
ystdv = np.polyval(coeffstd[ipeak],xarr)
assert np.all(ystdv > 0)
assert np.all(ystdv > 0)
intypeak = vround(ypeak)
intymin = intypeak - dextract
intymax = intypeak + dextract + 1
yarr = np.array([np.arange(intymin[j],intymax[j]) for j in range(Nxarr)])
allyarr[ipeak,:,xarr] = yarr
# Grab the relevant data into a flat array for fitting
datarr = np.zeros((Nxarr,Nextract))
errarr = np.zeros((Nxarr,Nextract))
for j,jx in enumerate(xarr):
datarr[j,:] = data[jx,intymin[j]:intymax[j]]
errarr[j,:] = edata[jx,intymin[j]:intymax[j]]
assert np.all(errarr > 0), (errarr <= 0).sum()
alldatarr[ipeak,xarr,:] = datarr
allerrarr[ipeak,xarr,:] = errarr
# Apply simple estimate of spectrum flux: sum everything
specestimate = np.sum(datarr, axis=1)
# Set up the polynomial grid in xl and ys
ys = (yarr.T-ypeak)/ystdv
expys = np.exp(-ys**2/2.)
xl = (xarr-np.mean(xarr))/(Nxarr/2.)
polygrid = np.zeros((Nxarr,Nextract,Nleg,Ngh))
La = [special.eval_legendre(a,xl)*specestimate for a in range(Nleg)]
GHb = [special.eval_hermitenorm(b,ys)*expys for b in range(Ngh)]
for a in range(Nleg):
for b in range(Ngh):
polygrid[:,:,a,b] = (GHb[b]*La[a]).T
polygrid = np.reshape(polygrid,(Nxy,Nparam))
# this is a *linear* least squares fit!
Xarr = np.reshape(polygrid,(Nxy,Nparam))
Yarr = np.ravel(datarr)
# use errors as weights. note that we don't square it, the squaring happens later
warr = np.ravel(errarr)**-1
wXarr = (Xarr.T*warr).T
wYarr = warr*Yarr
pfit, residues, rank, svals = linalg.lstsq(wXarr, wYarr)
fitparams[ipeak] = pfit
fity = pfit.dot(Xarr.T).reshape(Nxarr,Nextract)
allfitarr[ipeak][xarr,:] = fity
print("GHLB took {:.1f}s".format(time.time()-start))
np.savetxt(fname_fitparams,fitparams)
np.save(fname_allyarr,allyarr)
np.save(fname_alldatarr,alldatarr)
np.save(fname_allerrarr,allerrarr)
np.save(fname_allprofiles,allfitarr)
if make_plot:
import matplotlib.pyplot as plt
Nrow, Ncol = fibmap.shape
fig1, axes1 = plt.subplots(Nrow,Ncol,figsize = (Ncol*6,Nrow*2.5))
fig2, axes2 = plt.subplots(Nrow,Ncol,figsize = (Ncol*6,Nrow*2.5))
fig3, axes3 = plt.subplots(Nrow,Ncol,figsize = (Ncol*6,Nrow*2.5))
fig4, axes4 = plt.subplots(Nrow,Ncol,figsize = (Ncol*6,Nrow*2.5))
zplot = np.linspace(-6,6)
normz = np.exp(-0.5*zplot**2)/(2*np.sqrt(np.pi))
vmax3 = np.nanpercentile(alldatarr,[99.9])[0]
vmin4 = np.nanpercentile(allerrarr,[10])[0]
vmax4 = np.nanpercentile(allerrarr,[90])[0]
for ipeak, (ax1,ax2,ax3,ax4) in enumerate(zip(axes1.flat,axes2.flat,axes3.flat,axes4.flat)):
z = (alldatarr[ipeak].T-allfitarr[ipeak].T)/allerrarr[ipeak].T
im = ax1.imshow(z, origin='lower', aspect='auto',vmin=-6,vmax=6)
ax2.hist(np.ravel(z[np.isfinite(z)]),bins=zplot,normed=True)
ax2.plot(zplot,normz,lw=.5)
im = ax3.imshow(alldatarr[ipeak].T, origin='lower', aspect='auto',vmin=0,vmax=vmax3)
im = ax4.imshow(alldatarr[ipeak].T, origin='lower', aspect='auto',vmin=vmin4,vmax=vmax4)
outpre = outdir+"/"+outname
fig1.savefig(outpre+"_ghlbresid_zimg.png",bbox_inches='tight')
fig2.savefig(outpre+"_ghlbresid_hist.png",bbox_inches='tight')
fig3.savefig(outpre+"_ghlbresid_img.png",bbox_inches='tight')
fig4.savefig(outpre+"_ghlbresid_err.png",bbox_inches='tight')
plt.close(fig1); plt.close(fig2); plt.close(fig3); plt.close(fig4)
def f2(x, y, Jij):
return abs((-1)**Jij * special.eval_hermitenorm(Jij, y) /
factorial(Jij + 1)**2)**2