def test_mul(Poly):
c1 = list(random((4, )) + .5)
c2 = list(random((3, )) + .5)
p1 = Poly(c1)
p2 = Poly(c2)
p3 = p1 * p2
assert_poly_almost_equal(p2 * p1, p3)
assert_poly_almost_equal(p1 * c2, p3)
assert_poly_almost_equal(c2 * p1, p3)
assert_poly_almost_equal(p1 * tuple(c2), p3)
assert_poly_almost_equal(tuple(c2) * p1, p3)
assert_poly_almost_equal(p1 * np.array(c2), p3)
assert_poly_almost_equal(np.array(c2) * p1, p3)
assert_poly_almost_equal(p1 * 2, p1 * Poly([2]))
assert_poly_almost_equal(2 * p1, p1 * Poly([2]))
assert_raises(TypeError, op.mul, p1, Poly([0], domain=Poly.domain + 1))
assert_raises(TypeError, op.mul, p1, Poly([0], window=Poly.window + 1))
if Poly is Polynomial:
assert_raises(TypeError, op.mul, p1, Chebyshev([0]))
else:
assert_raises(TypeError, op.mul, p1, Polynomial([0]))
def test_normalize_parts():
w = np.arange(4000., 5000., 10.)
coeff = [1., 0.1, 0.1]
pol = Polynomial(coeff)
obs_spectrum = Spectrum1D.from_array(w, pol(w), dispersion_unit=u.AA)
parts = [slice(0, 30), slice(30, None)]
norm_parts = NormalizeParts(obs_spectrum, parts, npol=[3, 3])
model = Spectrum1D.from_array(w, np.ones_like(w), dispersion_unit=u.AA)
fit = norm_parts(model)
nptesting.assert_allclose(fit.flux.value, obs_spectrum.flux.value)
for normalizer in norm_parts.normalizers:
nptesting.assert_allclose(normalizer.polynomial.convert().coef,
np.array(coeff + [0.]), rtol=1e-3, atol=1.e-5)
# try also with boolean arrays
parts = [np.where(w < 4400.), np.where(w >= 4400.)]
norm_parts = NormalizeParts(obs_spectrum, parts, npol=[3, 3])
model = Spectrum1D.from_array(w, np.ones_like(w), dispersion_unit=u.AA)
fit = norm_parts(model)
nptesting.assert_allclose(fit.flux, obs_spectrum.flux)
for normalizer in norm_parts.normalizers:
nptesting.assert_allclose(normalizer.polynomial.convert().coef,
np.array(coeff + [0.]), rtol=1e-3, atol=1.e-5)
def env_residual_rms(env, xs, ys):
"""Calculate the RMS of the envelope fit residuals
Parameters
----------
env : np.ndarray
envelope parameters (polynomial coefficients)
xs : list
x values for the envelope fit
ys : list
y values for the envelope fit
Returns
-------
float
"""
xs = np.asarray(xs)
ys = np.asarray(ys)
resids = Polynomial(env)(xs) - ys
return np.std(resids)
def approx_legendre_poly(Moments):
n_moments = Moments.shape[0]-1
exp_coef = (np.zeros((1)))
# For method description see, for instance:
# Chapter 3 of "The Problem of Moments", James Alexander Shohat, Jacob David Tamarkin
for i in range(n_moments+1):
p = Legendre.basis(i).convert(window = [0.0,1.0], kind=Polynomial)
q = (2*i+1)*np.sum(Moments[0:(i+1)]*p.coef)
pq = (p.coef*q)
exp_coef = polynomial.polyadd(exp_coef, pq)
expansion = Polynomial(exp_coef)
return expansion
def parabola(initial_trajectory, speed):
"""
Find the quadratic form of the parabolic path
Parameters
----------
initial_trajectory : float
The initial angular trajectory of the path (degrees), measured from
the x-axis. A positive angle is in an anticlockwise direction.
speed : float
The initial speed of the object (m/s)
Returns
-------
eqn : np.polynomial.Polynomial object
Equation of parabolic path
"""
traj_rad = np.radians(initial_trajectory)
eqn = Polynomial([
0,
np.tan(traj_rad), -constants.g / 2. / (speed * np.cos(traj_rad))**2.
])
return eqn
def gradeSchoolParallel(poly1, poly2):
pRes = Polynomial(
[0 for _ in range(len(poly1.coef) + len(poly2.coef) - 1)])
nrWorkers = 4
step = len(poly1.coef) // nrWorkers
stepRemainder = len(poly1.coef) % nrWorkers
threads = []
for x in range(nrWorkers):
if stepRemainder != 0:
t = Thread(target=singleMultiplication,
args=(poly1, poly2, pRes, x * (step + 1),
(x + 1) * (step + 1)))
stepRemainder -= 1
else:
t = Thread(target=singleMultiplication,
args=(poly1, poly2, pRes,
x * step + len(poly1.coef) % nrWorkers,
(x + 1) * step + len(poly1.coef) % nrWorkers))
t.start()
threads.append(t)
for t in threads:
t.join()
return pRes
def evaluate(self, wavelength, flux):
# V[:,0]=mfi/e, Vp[:,1]=mfi/e*w, .., Vp[:,npol]=mfi/e*w**npol
V = self._Vp * (flux / self.observed.uncertainty.value)[:, np.newaxis]
# normalizes different powers
scl = np.sqrt((V * V).sum(0))
if np.isfinite(scl[0]): # check for validity before evaluating
sol, resids, rank, s = np.linalg.lstsq(V / scl,
self.signal_to_noise,
self._rcond)
sol = (sol.T / scl).T
if rank != self._Vp.shape[-1] - 1:
msg = "The fit may be poorly conditioned"
warnings.warn(msg)
fit = np.dot(V, sol) * self.observed.uncertainty.value
# keep coefficients in case the outside wants to look at it
self.polynomial = Polynomial(sol,
domain=self.domain.value,
window=self.window.value)
return wavelength, fit
else:
return wavelength, flux
def check_floordiv(Poly) :
c1 = list(random((4,)) + .5)
c2 = list(random((3,)) + .5)
c3 = list(random((2,)) + .5)
p1 = Poly(c1)
p2 = Poly(c2)
p3 = Poly(c3)
p4 = p1 * p2 + p3
c4 = list(p4.coef)
assert_poly_almost_equal(p4 // p2, p1)
assert_poly_almost_equal(p4 // c2, p1)
assert_poly_almost_equal(c4 // p2, p1)
assert_poly_almost_equal(p4 // tuple(c2), p1)
assert_poly_almost_equal(tuple(c4) // p2, p1)
assert_poly_almost_equal(p4 // np.array(c2), p1)
assert_poly_almost_equal(np.array(c4) // p2, p1)
assert_poly_almost_equal(2 // p2, Poly([0]))
assert_poly_almost_equal(p2 // 2, 0.5*p2)
assert_raises(TypeError, p1.__floordiv__, Poly([0], domain=Poly.domain + 1))
assert_raises(TypeError, p1.__floordiv__, Poly([0], window=Poly.window + 1))
if Poly is Polynomial:
assert_raises(TypeError, p1.__floordiv__, Chebyshev([0]))
else:
assert_raises(TypeError, p1.__floordiv__, Polynomial([0]))
def build_deriv_integrals_l2(q: int,
h: float,
B: List[Polynomial],
p: int,
left: int = 0,
right: int = None):
if right is None:
right = q
x = Polynomial([0., 1.])
c = []
for i in range(-q, q + 1):
curr = 0
for j in range(max(left, i), min(right, i + q) + 1):
l, r = j * h, j * h + h
first = B[j - i](x - i * h)
second = B[j]
integ = (first.deriv(p) * second.deriv(p)).integ()
curr += integ(r) - integ(l)
c.append(curr)
return c
def karatsubaSeq(poly1, poly2):
threshold = 20
if poly1.degree() <= threshold or poly2.degree() <= threshold:
return gradeSchoolSeq(poly1, poly2)
mid = max(len(poly1.coef), len(poly2.coef)) // 2
low1 = Polynomial(poly1.coef[:mid])
low2 = Polynomial(poly2.coef[:mid])
high1 = Polynomial(poly1.coef[mid:])
high2 = Polynomial(poly2.coef[mid:])
res1 = karatsubaThreaded(low1, low2)
res2 = karatsubaThreaded(low1 + high1, low2 + high2)
res3 = karatsubaThreaded(high1, high2)
return gradeSchoolSeq(res3, Polynomial([1] + [0 for _ in range(2 * mid)])) + \
gradeSchoolSeq((res2 - res1 - res3), Polynomial([1] + [0 for _ in range(mid)])) + \
res1
def karatsubaThreaded(poly1, poly2):
threshold = 20
if poly1.degree() <= threshold or poly2.degree() <= threshold:
return gradeSchoolSeq(poly1, poly2)
mid = max(len(poly1.coef), len(poly2.coef)) // 2
low1 = Polynomial(poly1.coef[:mid])
low2 = Polynomial(poly2.coef[:mid])
high1 = Polynomial(poly1.coef[mid:])
high2 = Polynomial(poly2.coef[mid:])
tp = ThreadPool(processes=3)
res1 = tp.apply_async(func=karatsubaThreaded, args=(low1, low2)).get()
res2 = tp.apply_async(func=karatsubaThreaded,
args=(low1 + high1, low2 + high2)).get()
res3 = tp.apply_async(func=karatsubaThreaded, args=(high1, high2)).get()
return gradeSchoolSeq(res3, Polynomial([1] + [0 for _ in range(2*mid)])) + \
gradeSchoolSeq((res2 - res1 - res3), Polynomial([1] + [0 for _ in range(mid)])) + \
res1
def hypergeometric_lyap_exp(self,
nb_vectors=None,
nb_experiments=10,
nb_iterations=10**4,
verbose=False,
output_file=None,
return_error=False):
r"""
Compute the Lyapunov exponents of the geodesic flow in the hypergeometric function
space.
INPUT:
- ``nb_vectors`` -- the number of vectors to use
- ``nb_experiments`` -- number of experimets
- ``nb_iterations`` -- the number of iterations of the induction to perform
- ``output_file`` -- place where we print the results
- ``verbose`` -- do we print the result with an extensive number of information or not
"""
import time
import lyapunov_exponents # the cython bindings
from math import sqrt
from cmath import exp, pi
from numpy.polynomial import Polynomial
if output_file is None:
from sys import stdout
output_file = stdout
closed = True
elif isinstance(output_file, str):
output_file = open(output_file, "w")
closed = False
if nb_vectors <> None and nb_vectors <= 0:
raise ValueError("the number of vectors must be positive")
if nb_experiments <= 0:
raise ValueError("the number of experiments must be positive")
if nb_iterations <= 0:
raise ValueError("the number of iterations must be positive")
#recall that the lyapunov exponents are symmetric
if nb_vectors == None:
nb_vectors = self._dimension // 2
if max(self.hodge_numbers()) == self._dimension:
if verbose:
output_file.write(
"by signature of the invariant hermitian form, all lyapunov exponents are 0\n"
)
if return_error:
return [0] * nb_vectors, [0] * nb_vectors, 0, 0
else:
return [0] * nb_vectors
n = self._dimension
alpha, beta = self._alpha, self._beta
p_zero, p_infinity = Polynomial(1 + 0 * 1j), Polynomial(1 + 0 * 1j)
for i in range(n):
p_zero *= Polynomial([-E(-alpha[i]), 1])
p_infinity *= Polynomial([-E(-beta[i]), 1])
t0 = time.time()
res = lyapunov_exponents.lyapunov_exponents(p_zero.coef,
p_infinity.coef,
self._dimension,
nb_vectors, nb_experiments,
nb_iterations)
t1 = time.time()
res_final = []
std_final = []
s_m, s_d = 0, 0
if verbose:
from math import floor, log
output_file.write("sample of %d experiments\n" % nb_experiments)
output_file.write(
"%d iterations (~2**%d)\n" %
(nb_iterations, floor(log(nb_iterations) / log(2))))
output_file.write("ellapsed time %s\n" %
time.strftime("%H:%M:%S", time.gmtime(t1 - t0)))
for i in xrange(nb_vectors):
m, d = mean_and_std_dev(res[i])
s_m += m
s_d += d**2
if verbose:
output_file.write(
"theta%d : %f (std. dev. = %f, conf. rad. 0.01 = %f)\n"
% (i, m, d, 2.576 * d / sqrt(nb_experiments)))
res_final.append(m)
std_final.append(2.576 * d / sqrt(nb_experiments))
s_d = sqrt(s_d)
s_d_final = 2.576 * s_d / sqrt(nb_experiments)
if verbose:
output_file.write(
"sum_theta : %f (std. dev. = %f, conf. rad. 0.01 = %f)\n\n"
% (s_m, s_d, 2.576 * s_d / sqrt(nb_experiments)))
if not closed:
output_file.close()
print "file closed"
if return_error:
return (res_final, std_final, s_m, s_d_final)
else:
return res_final
# psr = 'B1919+21'
# psr = 'B2016+28'
# psr = 'B1957+20'
# psr = 'B0329+54'
psr = 'J1810+1744'
dm_dict = {
'B0329+54': 26.833 * u.pc / u.cm**3,
'J1810+1744': 39.659298 * u.pc / u.cm**3,
'B1919+21': 12.455 * u.pc / u.cm**3,
'B1957+20': 29.11680 * 1.001 * u.pc / u.cm**3,
'B2016+28': 14.172 * u.pc / u.cm**3
}
phasepol_dict = {
'B0329+54':
Polynomial([0., 1.399541538720]),
'J1810+1744':
Polynomial([
5123935.3179235281, 601.3858344512422, -6.8670334150772988e-06,
1.6851467436247837e-10, 1.4924190280848832e-13,
3.681791676784501e-18, 3.4408214917205562e-22,
2.3962705401172674e-25, 2.7467843239802234e-29,
1.3396130966170961e-33, 3.0840132342990634e-38,
2.7633775352567796e-43
]),
'B1919+21':
Polynomial([0.5, 0.7477741603725]),
'B2016+28':
Polynomial([0., 1.7922641135652])
}
def g2(x):
p = Polynomial([2.0, 1.0, 0.0, -2.0, 2.5, 1.0])
return np.sqrt(p(x) / 6)
def from_endf(cls, ev, file_obj, items):
"""Create Reich-Moore resonance data from an ENDF evaluation.
Parameters
----------
ev : endf.Evaluation
ENDF evaluation
file_obj : file-like object
ENDF file positioned at the second record of a resonance range
subsection in MF=2, MT=151
items : list
Items from the CONT record at the start of the resonance range
subsection
Returns
-------
ReichMoore
Reich-Moore resonance parameters
"""
# Read energy-dependent scattering radius if present
energy_min, energy_max = items[0:2]
nro, naps = items[4:6]
if nro != 0:
params, ape = get_tab1_record(file_obj)
# Other scatter radius parameters
items = get_cont_record(file_obj)
target_spin = items[0]
ap = Polynomial((items[1], ))
angle_distribution = (items[3] == 1) # Flag for angular distribution
NLS = items[4] # Number of l-values
num_l_convergence = items[5] # Number of l-values for convergence
# Read resonance widths, J values, etc
channel_radius = {}
scattering_radius = {}
records = []
for i in range(NLS):
items, values = get_list_record(file_obj)
apl = Polynomial((items[1], )) if items[1] != 0.0 else ap
l_value = items[2]
awri = items[0]
# Calculate channel radius from ENDF-102 equation D.14
a = Polynomial((0.123 * (NEUTRON_MASS * awri)**(1. / 3.) + 0.08, ))
# Construct scattering and channel radius
if nro == 0:
scattering_radius[l_value] = apl
if naps == 0:
channel_radius[l_value] = a
elif naps == 1:
channel_radius[l_value] = apl
elif nro == 1:
if naps == 0:
channel_radius[l_value] = a
scattering_radius[l_value] = ape
elif naps == 1:
channel_radius[l_value] = scattering_radius[l_value] = ape
elif naps == 2:
channel_radius[l_value] = apl
scattering_radius[l_value] = ape
energy = values[0::6]
spin = values[1::6]
gn = values[2::6]
gg = values[3::6]
gfa = values[4::6]
gfb = values[5::6]
for i, E in enumerate(energy):
records.append([
energy[i], l_value, spin[i], gn[i], gg[i], gfa[i], gfb[i]
])
# Create pandas DataFrame with resonance data
columns = [
'energy', 'L', 'J', 'neutronWidth', 'captureWidth',
'fissionWidthA', 'fissionWidthB'
]
parameters = pd.DataFrame.from_records(records, columns=columns)
# Create instance of ReichMoore
rm = cls(target_spin, energy_min, energy_max, channel_radius,
scattering_radius)
rm.parameters = parameters
rm.angle_distribution = angle_distribution
rm.num_l_convergence = num_l_convergence
rm.atomic_weight_ratio = awri
return rm
def get_boundaries(bounddict_file, slitlet_number):
"""Read the bounddict json file and return the polynomial boundaries.
Parameters
----------
bounddict_file : file handler
File containing the bounddict JSON data.
slitlet_number : int
Number of slitlet.
Returns
-------
pol_lower_boundary : numpy polynomial
Polynomial defining the lower boundary of the slitlet.
pol_upper_boundary : numpy polynomial
Polynomial defining the upper boundary of the slitlet.
xmin_lower : float
Minimum abscissae for the lower boundary.
xmax_lower : float
Maximum abscissae for the lower boundary.
xmin_upper : float
Minimum abscissae for the upper boundary.
xmax_upper : float
Maximum abscissae for the upper boundary.
csu_bar_slit_center : float
CSU bar slit center (in mm)
"""
bounddict = json.loads(open(bounddict_file.name).read())
# return values in case the requested slitlet number is not defined
pol_lower_boundary = None
pol_upper_boundary = None
xmin_lower = None
xmax_lower = None
xmin_upper = None
xmax_upper = None
csu_bar_slit_center = None
# search the slitlet number in bounddict
slitlet_label = "slitlet" + str(slitlet_number).zfill(2)
if slitlet_label in bounddict['contents'].keys():
list_date_obs = list(bounddict['contents'][slitlet_label].keys())
list_date_obs.sort()
num_date_obs = len(list_date_obs)
if num_date_obs == 1:
date_obs = list_date_obs[0]
tmp_dict = bounddict['contents'][slitlet_label][date_obs]
pol_lower_boundary = Polynomial(tmp_dict['boundary_coef_lower'])
pol_upper_boundary = Polynomial(tmp_dict['boundary_coef_upper'])
xmin_lower = tmp_dict['boundary_xmin_lower']
xmax_lower = tmp_dict['boundary_xmax_lower']
xmin_upper = tmp_dict['boundary_xmin_upper']
xmax_upper = tmp_dict['boundary_xmax_upper']
csu_bar_slit_center = tmp_dict['csu_bar_slit_center']
else:
raise ValueError("num_date_obs =", num_date_obs, " (must be 1)")
else:
print("WARNING: slitlet number " + str(slitlet_number) +
" is not available in " + bounddict_file.name)
# return result
return pol_lower_boundary, pol_upper_boundary, \
xmin_lower, xmax_lower, xmin_upper, xmax_upper, \
csu_bar_slit_center
def setUP(self):
self.poly = Polynomial([1, 3, 2], [-3, 2])
self.inter = [-2, .0]
self.tol = 0.2
def polynomial(self,
index,
rphase=None,
deriv=0,
t0=None,
time_unit=u.min,
out_unit=None,
convert=False):
"""Prediction polynomial set up for times in MJD
Parameters
----------
index : int or float
index into the polyco table (or MJD for finding closest)
rphase : None or 'fraction' or float
phase zero point; if None, use the one stored in polyco.
(Those are typically large, so one looses some precision.)
Can also set 'fraction' to use the stored one modulo 1, which is
fine for folding, but breaks cycle count continuity between sets.
deriv : int
derivative of phase to take (1=frequency, 2=fdot, etc.); default 0
Returns
-------
polynomial : Polynomial
set up for MJDs between mjd_mid ± span
Notes
-----
Units for the polynomial are cycles/second**deriv. Taking a derivative
outside will be per day (e.g., self.polynomial(1).deriv() gives
frequencies in cycles/day)
"""
out_unit = out_unit or time_unit
try:
index = index.__index__()
except (AttributeError, TypeError):
index = self.searchclosest(index)
window = np.array([-1, 1]) * self['span'][index] / 2 * u.min
polynomial = Polynomial(self['coeff'][index], window.value,
window.value)
polynomial.coef[1] += self['f0'][index] * 60.
if deriv == 0:
if rphase is None:
polynomial.coef[0] += self['rphase'][index]
elif rphase == 'fraction':
polynomial.coef[0] += self['rphase'][index] % 1
else:
polynomial.coef[0] = rphase
else:
polynomial = polynomial.deriv(deriv)
polynomial.coef /= u.min.to(out_unit)**deriv
if t0 is None:
dt = 0. * time_unit
elif not hasattr(t0, 'jd1') and t0 == 0:
dt = (-self['mjd_mid'][index] * u.day).to(time_unit)
else:
dt = ((t0 - Time(self['mjd_mid'][index], format='mjd',
scale='utc')).jd * u.day).to(time_unit)
polynomial.domain = (window.to(time_unit) - dt).value
if convert:
return polynomial.convert()
else:
return polynomial
def from_endf(cls, file_obj, items, fission_widths):
"""Read unresolved resonance data from an ENDF evaluation.
Parameters
----------
file_obj : file-like object
ENDF file positioned at the second record of a resonance range
subsection in MF=2, MT=151
items : list
Items from the CONT record at the start of the resonance range
subsection
fission_widths : bool
Whether fission widths are given
Returns
-------
openmc.data.Unresolved
Unresolved resonance region parameters
"""
# Read energy-dependent scattering radius if present
energy_min, energy_max = items[0:2]
nro, naps = items[4:6]
if nro != 0:
params, ape = get_tab1_record(file_obj)
# Get SPI, AP, and LSSF
formalism = items[3]
if not (fission_widths and formalism == 1):
items = get_cont_record(file_obj)
target_spin = items[0]
if nro == 0:
ap = Polynomial((items[1], ))
add_to_background = (items[2] == 0)
if not fission_widths and formalism == 1:
# Case A -- fission widths not given, all parameters are
# energy-independent
NLS = items[4]
columns = ['L', 'J', 'd', 'amun', 'gn0', 'gg']
records = []
for ls in range(NLS):
items, values = get_list_record(file_obj)
awri = items[0]
l = items[2]
NJS = items[5]
for j in range(NJS):
d, j, amun, gn0, gg = values[6 * j:6 * j + 5]
records.append([l, j, d, amun, gn0, gg])
parameters = pd.DataFrame.from_records(records, columns=columns)
energies = None
elif fission_widths and formalism == 1:
# Case B -- fission widths given, only fission widths are
# energy-dependent
items, energies = get_list_record(file_obj)
target_spin = items[0]
if nro == 0:
ap = Polynomial((items[1], ))
add_to_background = (items[2] == 0)
NE, NLS = items[4:6]
records = []
columns = ['L', 'J', 'E', 'd', 'amun', 'amuf', 'gn0', 'gg', 'gf']
for ls in range(NLS):
items = get_cont_record(file_obj)
awri = items[0]
l = items[2]
NJS = items[4]
for j in range(NJS):
items, values = get_list_record(file_obj)
muf = items[3]
d = values[0]
j = values[1]
amun = values[2]
gn0 = values[3]
gg = values[4]
gfs = values[6:]
for E, gf in zip(energies, gfs):
records.append([l, j, E, d, amun, muf, gn0, gg, gf])
parameters = pd.DataFrame.from_records(records, columns=columns)
elif formalism == 2:
# Case C -- all parameters are energy-dependent
NLS = items[4]
columns = [
'L', 'J', 'E', 'd', 'amux', 'amun', 'amuf', 'gx', 'gn0', 'gg',
'gf'
]
records = []
for ls in range(NLS):
items = get_cont_record(file_obj)
awri = items[0]
l = items[2]
NJS = items[4]
for j in range(NJS):
items, values = get_list_record(file_obj)
ne = items[5]
j = items[0]
amux = values[2]
amun = values[3]
amuf = values[5]
energies = []
for k in range(1, ne + 1):
E = values[6 * k]
d = values[6 * k + 1]
gx = values[6 * k + 2]
gn0 = values[6 * k + 3]
gg = values[6 * k + 4]
gf = values[6 * k + 5]
energies.append(E)
records.append(
[l, j, E, d, amux, amun, amuf, gx, gn0, gg, gf])
parameters = pd.DataFrame.from_records(records, columns=columns)
# Calculate channel radius from ENDF-102 equation D.14
a = Polynomial((0.123 * (NEUTRON_MASS * awri)**(1. / 3.) + 0.08, ))
# Determine scattering and channel radius
if nro == 0:
scattering_radius = ap
if naps == 0:
channel_radius = a
elif naps == 1:
channel_radius = ap
elif nro == 1:
scattering_radius = ape
if naps == 0:
channel_radius = a
elif naps == 1:
channel_radius = ape
elif naps == 2:
channel_radius = ap
urr = cls(target_spin, energy_min, energy_max, channel_radius,
scattering_radius)
urr.parameters = parameters
urr.add_to_background = add_to_background
urr.atomic_weight_ratio = awri
urr.energies = energies
return urr
"""
from __future__ import division, absolute_import, print_function
import operator as op
from numbers import Number
import numpy as np
from numpy.polynomial import (Polynomial, Legendre, Chebyshev, Laguerre,
Hermite, HermiteE)
from numpy.testing import (assert_almost_equal, assert_raises, assert_equal,
assert_, run_module_suite)
from numpy.compat import long
classes = (Polynomial, Legendre, Chebyshev, Laguerre, Hermite, HermiteE)
np.negative(Polynomial([0]))
def test_class_methods():
for Poly1 in classes:
for Poly2 in classes:
yield check_conversion, Poly1, Poly2
yield check_cast, Poly1, Poly2
for Poly in classes:
yield check_call, Poly
yield check_identity, Poly
yield check_basis, Poly
yield check_fromroots, Poly
yield check_fit, Poly
yield check_equal, Poly
yield check_not_equal, Poly
poly_order)
### Reconstruct data
bb_reconstructed = gs.wien_approximation(wl_sub_vec,Tave,bb_eps)
eps_vec_reconstructed = np.exp(filtered_data)/bb_reconstructed
# Since we get epsilon from the filtered data, "reconstructed_data" will be
# exactly like "filtered_data"
reconstructed_data = bb_reconstructed * eps_vec_reconstructed # exactly filtered
# Alternative using the polynomial from optimization
reconstructed_alt = gs.wien_approximation(wl_sub_vec,Tave,bb_eps)
wl_min = np.min(wl_sub_vec)
wl_max = np.max(wl_sub_vec)
if poly_order > 0:
cheb = Polynomial(sol.x,[wl_min,wl_max])
eps_vec = polynomial.polyval(wl_sub_vec,cheb.coef)
else:
eps_ave = np.average(eps_vec_reconstructed)
eps_vec = eps_ave * np.ones(len(wl_sub_vec))
reconstructed_alt *= eps_vec
#### Plots
data = np.genfromtxt('data/duvaut-1995/tantalum-irradiance.csv', delimiter=',',skip_header=1)
radiance = data[:,1] / 1e7
wl_vec_radiance = data[:,0] * 1000 # Wavelengths are in micro-meter
fig, ax = plt.subplots(2,1)
0.0016072823189784409,
1337.21932367595014])
gates = np.zeros((4,4))
gates[1] = [59,60,61,62]
gates[2] = [1,8,9,16]
gates[3] = [224,226,227,231]
# Fiddle with DM of 1957
dm0[2] *= 1.001
# select pulsar
psr = psrname[ipsr]
dm = dm0[ipsr]
t0 = -p00[ipsr]/3.
f0 = 622.1678503154773 # 1./p00[ipsr]
f1 = 1.45706137397e-06/2. # 0.
phasepol = Polynomial([f0, f1]).integ(1, 0., t0)
igate = gates[ipsr]
fndir1 = '/mnt/raid-project/gmrt/pen/B1937/1957+20/b'
file1 = fndir1 + psr + '_pa.raw0.Pol-L1.dat'
file2 = fndir1 + psr + '_pa.raw0.Pol-L2.dat'
nhead = 0*32*1024*1024
# frequency samples in a block; every sample is two bytes: real, imag
nblock = 512
# nt=45 for 1508, 180 for 0809 and 156 for 0531
nt = 1024//2*8*2 # number of sets to fold -> //128 for quick try
ntint = 1024*32*1024//(nblock*2)//4 # total # of blocks per set
ngate = 32//2 # number of bins over the pulsar period
ntbin = 16*1 # number of bins the time series is split into for folding
ntw = min(10000, nt*ntint) # number of samples to combine for waterfall
def polydiv_coef(p: Polynomial, mod: int) -> Polynomial:
return Polynomial([c % mod for c in p.coef])
d_correct = f.deriv(2)
for h_i in h:
f_error = np.append(f_error, [((h_i * Y_correct) / 2.0)])
b_error = np.append(b_error, [((h_i * Y_correct) / 2.0)])
c_error = np.append(c_error, [((h_i * h_i * d_correct(x)) / 6)])
return f_error, b_error, c_error
##################################
fig, ax = plt.subplots()
ax.axhline(y=0, color='k')
p = Polynomial([2.0, 1.0, -6.0, -2.0, 2.5, 1.0])
data = p.linspace(domain=[-2.4, 1.5])
ax.plot(data[0], data[1], label='Function')
p_prime = p.deriv(1)
data2 = p_prime.linspace(domain=[-2.4, 1.5])
ax.plot(data2[0], data2[1], label='Derivative')
ax.legend()
##################################
h = 1
fig, bx = plt.subplots()
bx.axhline(y=0, color='k')
def from_endf(cls, ev, file_obj, items):
"""Create MLBW data from an ENDF evaluation.
Parameters
----------
ev : endf.Evaluation
ENDF evaluation
file_obj : file-like object
ENDF file positioned at the second record of a resonance range
subsection in MF=2, MT=151
items : list
Items from the CONT record at the start of the resonance range
subsection
Returns
-------
MultiLevelBreitWigner
Multi-level Breit-Wigner resonance parameters
"""
# Read energy-dependent scattering radius if present
energy_min, energy_max = items[0:2]
nro, naps = items[4:6]
if nro != 0:
params, ape = get_tab1_record(file_obj)
# Other scatter radius parameters
items = get_cont_record(file_obj)
target_spin = items[0]
ap = Polynomial((items[1], )) # energy-independent scattering-radius
NLS = items[4] # number of l-values
# Read resonance widths, J values, etc
channel_radius = {}
scattering_radius = {}
q_value = {}
records = []
for l in range(NLS):
items, values = get_list_record(file_obj)
l_value = items[2]
awri = items[0]
q_value[l_value] = items[1]
competitive = items[3]
# Calculate channel radius from ENDF-102 equation D.14
a = Polynomial((0.123 * (NEUTRON_MASS * awri)**(1. / 3.) + 0.08, ))
# Construct scattering and channel radius
if nro == 0:
scattering_radius[l_value] = ap
if naps == 0:
channel_radius[l_value] = a
elif naps == 1:
channel_radius[l_value] = ap
elif nro == 1:
scattering_radius[l_value] = ape
if naps == 0:
channel_radius[l_value] = a
elif naps == 1:
channel_radius[l_value] = ape
elif naps == 2:
channel_radius[l_value] = ap
energy = values[0::6]
spin = values[1::6]
gt = np.asarray(values[2::6])
gn = np.asarray(values[3::6])
gg = np.asarray(values[4::6])
gf = np.asarray(values[5::6])
if competitive > 0:
gx = gt - (gn + gg + gf)
else:
gx = np.zeros_like(gt)
for i, E in enumerate(energy):
records.append([
energy[i], l_value, spin[i], gt[i], gn[i], gg[i], gf[i],
gx[i]
])
columns = [
'energy', 'L', 'J', 'totalWidth', 'neutronWidth', 'captureWidth',
'fissionWidth', 'competitiveWidth'
]
parameters = pd.DataFrame.from_records(records, columns=columns)
# Create instance of class
mlbw = cls(target_spin, energy_min, energy_max, channel_radius,
scattering_radius)
mlbw.q_value = q_value
mlbw.atomic_weight_ratio = awri
mlbw.parameters = parameters
return mlbw
def polynomial(self,
index,
rphase=None,
deriv=0,
t0=None,
time_unit=u.min,
out_unit=None,
convert=False):
"""Prediction polynomial set up for times in MJD
Parameters
----------
index : int or float
index into the polyco table (or MJD for finding closest)
rphase : None or 'fraction' or 'ignore' or float
Phase zero point; if None, use the one stored in polyco.
(Those are typically large, so one looses some precision.)
Can also set 'fraction' to use the stored one modulo 1, which is
fine for folding, but breaks cycle count continuity between sets,
'ignore' for just keeping the value stored in the coefficients,
or a value that should replace the zero point.
deriv : int
derivative of phase to take (1=frequency, 2=fdot, etc.); default 0
Returns
-------
polynomial : Polynomial
set up for MJDs between mjd_mid +/- span
Notes
-----
Units for the polynomial are cycles/second**deriv. Taking a derivative
outside will be per day (e.g., self.polynomial(1).deriv() gives
frequencies in cycles/day)
"""
out_unit = out_unit or time_unit
try:
index = index.__index__()
except (AttributeError, TypeError):
index = self.searchclosest(index)
window = np.array([-1, 1]) * self['span'][index] / 2
polynomial = Polynomial(self['coeff'][index], window.value,
window.value)
polynomial.coef[1] += self['f0'][index].to_value(u.cycle / u.minute)
if deriv == 0:
if rphase is None:
polynomial.coef[0] += self['rphase'][index].value
elif rphase == 'fraction':
polynomial.coef[0] += self['rphase']['frac'][index].value % 1
elif rphase != 'ignore':
polynomial.coef[0] = rphase
else:
polynomial = polynomial.deriv(deriv)
polynomial.coef /= u.min.to(out_unit)**deriv
if t0 is not None:
dt = Time(t0, format='mjd') - self['mjd_mid'][index]
polynomial.domain = (window - dt).to(time_unit).value
if convert:
return polynomial.convert()
else:
return polynomial
# -*- coding: utf-8 -*-
"""lab6B.py
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/13GdeGlRUzt1Naw5YFzzsALPKT1dLmrut
"""
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from numpy.polynomial import Polynomial
f = Polynomial([2.0, 1.0, -6.0, -2.0, 2.5, 1.0])
g1 = Polynomial([-2.0, 0.0, 6.0, 2.0, -2.5, -1.0])
def g2(x):
p = Polynomial([2.0, 1.0, 0.0, -2.0, 2.5, 1.0])
return np.sqrt(p(x) / 6)
def g3(x):
p = Polynomial([-2.0, -1.0, 6.0, 2.0, 0.0, -1.0])
return np.power(p(x) / 2.5, 1.0 / 4.0)
a1 = 0.8
g1_a = []
def plot_polynomial(f, x, c=4):
y = [f(x_i) for x_i in x]
if ii == 0:
plt.plot(x, [y_i - c for y_i in y], ls='-',
c="black", label=round(ii, 1))
plt.plot(x, [y_i + c for y_i in y], ls='-', c="black")
else:
plt.plot(x, [y_i - c for y_i in y], ls='--', label=round(ii, 1))
plt.subplot(2, 3, 1)
plt.ylim((-10, 14))
plt.title('$f(x) = a \cdot x + c$')
for ii in seq(-0.5, 0.2, by=0.1):
plot_polynomial(Polynomial([0., 1. + ii]), seq(0, 4))
plt.subplot(2, 3, 2)
plt.title('$f(x) = a \cdot x^2 + c$')
for ii in seq(-0.5, 0.2, by=0.1):
plot_polynomial(Polynomial([0., 0., 1. + ii]), seq(0, 4))
plt.subplot(2, 3, 3)
plt.title('$f(x) = a \cdot x^3 + c$')
for ii in seq(-0.5, 0.2, by=0.1):
plot_polynomial(Polynomial([0., 0., 0., 1. + ii]), seq(0, 4))
lgd = plt.legend(title='$\delta = a - a_{ref}$',
bbox_to_anchor=(1.04, 1.04),
loc="upper left")
plt.savefig('../plots/examples.pdf', bbox_extra_artists=(lgd,), bbox_inches='tight',
def g3(x):
p = Polynomial([-2.0, -1.0, 6.0, 2.0, 0.0, -1.0])
return np.power(p(x) / 2.5, 1.0 / 4.0)
import sympy
from numpy.polynomial import Polynomial
from numpy.polynomial import Chebyshev
from sympy.abc import x
import scipy.optimize
def T(n_):
return Chebyshev(np.append(np.zeros(n_), 1))
a = 0
b = 2
P_n = Polynomial([0, 1, 0, 1]) # 0 + 1*x + 0*x^2 + 1*x^3
n = P_n.degree()
# Zero approximation
P_n_min = scipy.optimize.fminbound(P_n, a, b, full_output=True)[1]
P_n_max = -scipy.optimize.fminbound(-P_n, a, b, full_output=True)[1]
Q0 = (P_n_max + P_n_min) / 2
# First approximation
alpha1 = (P_n(b) - P_n(a)) / (b - a)
r = (P_n.deriv() - Polynomial([alpha1])).roots()
d = next(t for t in r if a < t < b)
alpha0 = (P_n(a) + P_n(d) - alpha1 * (a + d)) / 2
Q1 = alpha0 + alpha1 * x
Q1 = sympy.lambdify(x, Q1)
