def H_mag(num, den, z, H_max, H_min = None, log = False, div_by_0 = 'ignore'):
"""
Calculate `|H(z)|` at the complex frequency(ies) `z` (scalar or
array-like). The function `H(z)` is given in polynomial form with numerator and
denominator. When log = True, `20 log_10 (|H(z)|)` is returned.
The result is clipped at H_min, H_max; clipping can be disabled by passing
None as the argument.
Parameters
----------
num : float or array-like
The numerator polynome of H(z).
den : float or array-like
The denominator polynome of H(z).
z : float or array-like
The complex frequency(ies) where `H(z)` is to be evaluated
H_max : float
The maximum value to which the result is clipped
H_min : float, optional
The minimum value to which the result is clipped (default: 0)
log : boolean, optional
When true, return 20 * log10 (|H(z)|). The clipping limits have to
be given as dB in this case.
div_by_0 : string, optional
What to do when division by zero occurs during calculation (default:
'ignore'). As the denomintor of H(z) becomes 0 at each pole, warnings
are suppressed by default. This parameter is passed to numpy.seterr(),
hence other valid options are 'warn', 'raise' and 'print'.
Returns
-------
H_mag : float or ndarray
The magnitude |`H(z)`| for each value of `z`.
"""
try: len(num)
except TypeError:
num_val = abs(num) # numerator is a scalar
else:
num_val = abs(np.polyval(num, z)) # evaluate numerator at z
try: len(den)
except TypeError:
den_val = abs(den) # denominator is a scalar
else:
den_val = abs(np.polyval(den, z)) # evaluate denominator at z
olderr = np.geterr() # store current floating point error behaviour
# turn off divide by zero warnings, just return 'inf':
np.seterr(divide = 'ignore')
if log:
H_val = 20 * np.log10(num_val / den_val)
else:
H_val = num_val / den_val
np.seterr(**olderr) # restore previous floating point error behaviour
# clip result to H_min / H_max
return np.clip(H_val, H_min, H_max)
def cd_sphere_vector_bool(Re):
from numpy import log10,array,polyval
condition1 = Re < 0
condition2 = logical_and(0 < Re, Re <= 0.5)
condition3 = logical_and(0.5 < Re, Re <= 100.0)
condition4 = logical_and(100.0 < Re, Re <= 1.0e4)
condition5 = logical_and(1.0e4 < Re, Re <= 3.35e5)
condition6 = logical_and(3.35e5< Re, Re <= 5.0e5)
condition7 = logical_and(5.0e5 < Re, Re <= 8.0e6)
condition8 = Re > 8.0e6
cd = zeros_like(Re)
cd[condition1] = 0.0
cd[condition2] = 24/Re[condition2]
p = array([4.22,-14.05,34.87,0.658])
cd[condition3] = polyval(p,1.0/Re[condition3])
p = array([-30.41,43.72,-17.08,2.41])
cd[condition4] = polyval(p,1.0/log10(Re[condition4]))
p = array([-0.1584,2.031,-8.472,11.932])
cd[condition5] = polyval(p,log10(Re[condition5]))
cd[condition6] = 91.08*(log10(Re[condition6]/4.5e5))**4 + 0.0764
p = array([-0.06338,1.1905,-7.332,14.93])
cd[condition7] = polyval(p,log10(Re[condition7]))
cd[condition8] = 0.2
return cd
def cd_sphere(Re):
"Computes the drag coefficient of a sphere as a function of the Reynolds number Re."
# Curve fitted after fig . A -56 in Evett & Liu :% " Fluid Mechanics & Hydraulics ",
# Schaum ' s Solved Problems McGraw - Hill 1989.
from numpy import log10,array,polyval
if Re <= 0.0:
CD = 0.0
elif Re > 8.0e6:
CD = 0.2
elif Re > 0.0 and Re <= 0.5:
CD = 24.0/Re
elif Re > 0.5 and Re <= 100.0:
p = array([4.22,-14.05,34.87,0.658])
CD = polyval(p,1.0/Re)
elif Re > 100.0 and Re <= 1.0e4:
p = array([-30.41,43.72,-17.08,2.41])
CD = polyval(p,1.0/log10(Re))
elif Re > 1.0e4 and Re <= 3.35e5:
p = array([-0.1584,2.031,-8.472,11.932])
CD = polyval(p,log10(Re))
elif Re > 3.35e5 and Re <= 5.0e5:
x1 = log10(Re/4.5e5)
CD = 91.08*x1**4 + 0.0764
else:
p = array([-0.06338,1.1905,-7.332,14.93])
CD = polyval(p,log10(Re))
return CD
def calibrate(self, title, rng=None, cal=None):
""" Returns calibrated bin centers for saved histogram with given title.
If the cal argument is given, title must exactly match a key in the file
self.ofile.
"title" title of histogram. If cal is not None then title must exactly
match a key in the hdf5 file self.ofile.
"rng" is the index range of elements to return
"cal" is a set of polynomial coefficients for np.polyval. A linear
scaling by a factor s would require cal=[s,0]
"""
rng = rng or [None, None]
if cal is None:
bins = self.bcent(title, rng)
return np.polyval(self.cal, bins)
else:
with h5py.File(self.ofile, 'r') as ofile:
if title not in ofile.keys():
raise ValueError(title + ' is not in file ' + self.ofile)
elif title[0] == 'b':
bins = self.bcent(title[1:], rng)
return np.polyval(cal, bins)
else:
axis = ofile[title][rng[0]:rng[1]]
return np.polyval(cal, axis)
def cd_sphere_vector(Re):
"Computes the drag coefficient of a sphere as a function of the Reynolds number Re."
# Curve fitted after fig . A -56 in Evett & Liu :% " Fluid Mechanics & Hydraulics ",
# Schaum ' s Solved Problems McGraw - Hill 1989.
from numpy import log10,array,polyval
CD = zeros_like(Re)
CD = where(Re<0,0.0,0.0) # condition 1
CD = where((Re > 0.0) & (Re <=0.5),24/Re,CD) # condition 2
p = array([4.22,-14.05,34.87,0.658])
CD = where((Re > 0.5) & (Re <=100.0),polyval(p,1.0/Re),CD) #condition 3
p = array([-30.41,43.72,-17.08,2.41])
CD = where((Re >100.0) & (Re <=1.0e4) ,polyval(p,1.0/log10(Re)),CD) #condition 4
p = array([-0.1584,2.031,-8.472,11.932])
CD = where((Re > 1.0e4) & (Re <=3.35e5),polyval(p,log10(Re)),CD) #condition 5
CD = where((Re > 3.35e5) & (Re <=5.0e5),91.08*(log10(Re/4.5e5))**4 + 0.0764,CD) #condition 6
p = array([-0.06338,1.1905,-7.332,14.93])
CD = where((Re > 5.05e5) & (Re <=8.0e6),polyval(p,log10(Re)),CD) #condition 7
CD = where(Re>8.0e6,0.2,CD) # condition 8
return CD
def getParams(inputF,cosineScore,error,lib,minimumFeature):
# parse the argument
def search(lib,row):
if row['INCHI'] in lib:
return lib[row['INCHI']]
return -1
df = pd.read_csv(inputF,sep='\t')
# filter out by cosinScore
df = df[df.MQScore > cosineScore]
# search for ki average
lib_df = pd.read_csv(lib)
lib_df = lib_df[lib_df.polarity.str.contains('non-polar')]
lib = pd.Series(lib_df.ki_nonpolar_average.values,index=lib_df.INCHI.values).to_dict()
df['ki_average'] = df.apply(lambda row:search(lib,row),axis = 1)
df = df[df.ki_average>0]
#clean the data for polynomial fitting:
df = df[df['ki_average']>500]
df = df[df.RT_Query<800]
if len(df) < minimumFeature:
return None
#simply find the polynomial fitting
p_a = np.polyfit(df.RT_Query,df.ki_average,2)
# we fit it twice to have more robust results:
df =df[abs(df.ki_average-np.polyval(p_a,df.RT_Query))/np.polyval(p_a,df.RT_Query)<error]
p_b = np.polyfit(df.RT_Query,df.ki_average,2)
return p_b
def showExamplePolyFit(xs,ys,fitDegree1 = 1,fitDegree2 = 2):
pylab.figure()
pylab.plot(xs,ys,'r.',ms=2.0,label = "measured")
# poly fit to noise
coeeff = numpy.polyfit(xs, ys, fitDegree1)
# Predict the curve
pys = numpy.polyval(numpy.poly1d(coeeff), xs)
se = mse(ys, pys)
r2 = rSquared(ys, pys)
pylab.plot(xs,pys, 'g--', lw=5,label="%d degree fit, SE = %0.10f, R2 = %0.10f" %(fitDegree1,se,r2))
# Poly fit to noise
coeeffs = numpy.polyfit(xs, ys, fitDegree2)
# Predict the curve
pys = numpy.polyval(numpy.poly1d(coeeffs), xs)
se = mse(ys, pys)
r2 = rSquared(ys, pys)
pylab.plot(xs,pys, 'b--', lw=5,label="%d degree fit, SE = %0.10f, R2 = %0.10f" %(fitDegree2,se,r2))
pylab.legend()
def fit(data, nz):
x = [0 for iz in range(0, nz, 1)]
y = [0 for iz in range(0, nz, 1)]
z = [iz for iz in range(0, nz, 1)]
for iz in range(0, nz, 1):
x[iz], y[iz] = ndimage.measurements.center_of_mass(np.array(data[:,:,iz]))
#Fit centerline in the Z-X plane using polynomial function
print '\nFit centerline in the Z-X plane using polynomial function...'
coeffsx = np.polyfit(z, x, 1)
polyx = np.poly1d(coeffsx)
x_fit = np.polyval(polyx, z)
print 'x_fit'
print x_fit
#Fit centerline in the Z-Y plane using polynomial function
print '\nFit centerline in the Z-Y plane using polynomial function...'
coeffsy = np.polyfit(z, y, 1)
polyy = np.poly1d(coeffsy)
y_fit = np.polyval(polyy, z)
#### 3D plot
fig1 = plt.figure()
ax = Axes3D(fig1)
ax.plot(x,y,z,zdir='z')
ax.plot(x_fit,y_fit,z,zdir='z')
plt.show()
return x, y, x_fit, y_fit
def sampleR3(averagedist,boxdims):
"""low-discrepancy sampling using primes.
The samples are evenly distributed with an average distance of averagedist inside the box with dimensions boxdims.
Algorithim from "Geometric Discrepancy: An Illustrated Guide" by Jiri Matousek"""
minaxis = numpy.argmin(boxdims)
maxaxis = numpy.argmax(boxdims)
meddimdist = numpy.sort(boxdims)[1]
# convert average distance to number of samples.... do simple 3rd degree polynomial fitting...
x = meddimdist/averagedist
if x < 25.6:
N = int(numpy.polyval([ -3.50181522e-01, 2.70202333e+01, -3.10449514e+02, 1.07887093e+03],x))
elif x < 36.8:
N = int(numpy.polyval([ 4.39770585e-03, 1.10961031e+01, -1.40066591e+02, 1.24563464e+03],x))
else:
N = int(numpy.polyval([5.60147111e-01, -8.77459988e+01, 7.34286834e+03, -1.67779452e+05],x))
pts = numpy.zeros((N,3))
pts[:,0] = numpy.linspace(0.0,meddimdist,N)
pts[:,1] = meddimdist*numpy.mod(0.5+0.5*numpy.sqrt(numpy.arange(0,5.0*N,5.0)),1.0)
pts[:,2] = meddimdist*numpy.mod(0.5+3*numpy.sqrt(numpy.arange(0,13.0*N,13.0)),1.0)
if boxdims[minaxis] < meddimdist:
pts = pts[pts[:,minaxis]<=boxdims[minaxis],:]
if boxdims[maxaxis] > meddimdist:
# have to copy across the max dimension
numfullcopies = numpy.floor(boxdims[maxaxis]/meddimdist)
oldpts = pts
pts = numpy.array(oldpts)
for i in range(int(numfullcopies)-1):
oldpts[:,maxaxis] += meddimdist
pts = numpy.r_[pts,oldpts]
if boxdims[maxaxis]/meddimdist > numfullcopies:
oldpts[:,maxaxis] += meddimdist
pts = numpy.r_[pts,oldpts[oldpts[:,maxaxis]<=boxdims[maxaxis],:]]
return pts
def nan_detrend(x, y, deg=1):
"""Subtract a polynomial fit from the data, ignoring NaNs.
Parameters
----------
x : array_like
x data.
y : array_like
Data to detrend.
deg : int
Degree of polynomial to subtract. (Can be zero i.e. constant)
Returns
-------
y_out : numpy.array
Detrended data.
"""
y_out = np.nan*np.zeros_like(y)
if np.ndim(x) == 1:
nans = np.isnan(x) | np.isnan(y)
p = nan_polyfit(x, y, deg)
y_out[~nans] = y[~nans] - np.polyval(p, x[~nans])
elif np.ndim(x) == 2:
for i in xrange(x.shape[1]):
nans = np.isnan(x[:, i]) | np.isnan(y[:, i])
p = nan_polyfit(x[:, i], y[:, i], deg)
y_out[~nans, i] = y[~nans, i] - np.polyval(p, x[~nans, i])
else:
raise RuntimeError('Arguments must be 1 or 2 dimensional arrays.')
return y_out
def _make_axes(self):
'''Construct axes from calibration fields in header file
'''
xcalib = self.header.xcalibration
ycalib = self.header.ycalibration
xcalib_valid = struct.unpack('?', xcalib.calib_valid)
if xcalib_valid:
xcalib_order, = struct.unpack('>B', xcalib.polynom_order) # polynomial order
px = xcalib.polynom_coeff[:xcalib_order+1]
px = np.array(px[::-1]) # reverse coefficients to use numpy polyval
pixels = np.arange(1, self.header.xdim + 1)
px = np.polyval(px, pixels)
else:
px = np.arange(1, self.header.xdim + 1)
ycalib_valid = struct.unpack('?', ycalib.calib_valid)
if ycalib_valid:
ycalib_order, = struct.unpack('>B', ycalib.polynom_order) # polynomial order
py = ycalib.polynom_coeff[:ycalib_order+1]
py = np.array(py[::-1]) # reverse coefficients to use numpy polyval
pixels = np.arange(1, self.header.ydim + 1)
py = np.polyval(py, pixels)
else:
py = np.arange(1, self.header.ydim + 1)
self._xaxis = px
self._yaxis = py
return px, py
def set_limits_by_zoom(self, zoom, cx, cy, canvas=None):
'''
'''
def _set_limits(axis_key, px_per_cm, cur_pos, canvas):
if axis_key == 'x':
d = self.width
else:
d = self.height
# scale to mm
if canvas is None:
canvas = self.parent
if canvas:
d /= 2.0 * px_per_cm / 10.0
lim = (-d + cur_pos, d + cur_pos)
canvas.set_mapper_limits(axis_key, lim)
cdata = self.calibration_data
xpx_per_cm = np.polyval(cdata.get_xcoeffs(), [zoom])[0]
ypx_per_cm = np.polyval(cdata.get_ycoeffs(), [zoom])[0]
_set_limits('x', xpx_per_cm, cx, canvas)
_set_limits('y', ypx_per_cm, cy, canvas)
def plot_fit(deg, err):
try:
polcoefs = np.polyfit(x_rand, y_rand, deg)
except np.RankWarning:
pass
if err:
fig = plt.figure(figsize=(15, 10))
gs = gridspec.GridSpec(2, 1, height_ratios=[3, 1])
ax = plt.subplot(gs[0])
else:
fig, ax = plt.subplots(1, 1, figsize=(15, 10))
# data
ax.plot(x_cont, np.polyval(polcoefs, x_cont))
ax.legend(['degree {}'.format(deg)])
plot_dat(ax, err)
# error
if err:
train_error.append(sum((np.polyval(polcoefs, x_rand)-y_rand)**2)/len(x_rand))
test_error.append(sum((np.polyval(polcoefs, x_test)-y_test)**2)/len(x_test))
ax = plt.subplot(gs[1])
ax.plot(deg_list[0:len(train_error)], train_error, marker='o', c=(0, 0, 1))
ax.plot(deg_list[0:len(test_error)], test_error, marker='o', c=(0.9, 0, 0))
ax.set_xlabel('degree')
ax.set_ylabel('error')
ax.legend(['train', 'test'])
ax.set_xlim(0.9, deg_list[-1]+0.1)
ax.set_ylim(0, None)
ax.set_yticks([])
# layout
plt.tight_layout()
def measure_dA_dphi_fir(lock, li, tp, dA_dphi_before, dA_dphi_after):
"""Correct for impulsive phase shift at end of pulse time."""
i_tp = np.arange(lock.t.size)[lock.t < tp][-1]
# Use 20 data points for interpolating; this is slightly over one
# cycle of our oscillation
m = np.arange(-10, 11) + i_tp
# This interpolator worked reasonably for similar, low-frequency sine waves
interp = interpolate.KroghInterpolator(lock.t[m], lock.x[m])
x0 = interp(tp)[()]
# We only need t0 approximately; the precise value of f0 doesn't matter very much.
t0 = li.t[(li.t < tp)][-1]
f0 = li.df[(li.t < tp)][-1] + li.f0(t0)
v0 = interp.derivative(tp)[()]
x2 = v0 / (2*np.pi*f0)
phi0 = np.arctan2(-x2, x0)
ml = masklh(li.t, tp-t_fit, tp)
mr = masklh(li.t, tp, tp + t_fit)
A = abs(li.z_out)
phi = np.unwrap(np.angle(li.z_out))/(2*np.pi)
mbAl = np.polyfit(li.t[ml], A[ml], 1)
mbAr = np.polyfit(li.t[mr], A[mr], 1)
mb_phi_l = np.polyfit(li.t[ml], phi[ml], 1)
mb_phi_r = np.polyfit(li.t[mr], phi[mr], 1)
dA = np.polyval(mbAr, tp) - np.polyval(mbAl, tp)
dphi = np.polyval(mb_phi_r, tp) - np.polyval(mb_phi_l, tp)
return phi0, dA, dphi
def corrNonlinGetPar(linearDet,nonLinearDet,order=2,data_0=0,
correct_0=0,plot=False,returnCorrectedDet=False):
""" Find parameters for non linear correction
*linearDet* should be an 1D array of the detector that is linear
*nonLinearDet* is the detector that is sussposed to be none linear
*data_0" is an offset to use for the data (used only if plotting)"
*correct_0* offset of the "linear detector"""
p = np.polyfit(nonLinearDet,linearDet,order)
p[-1] = p[-1]-correct_0
if plot:
d = corrNonlin(nonLinearDet,p,data_0=data_0,correct_0=correct_0)
plt.plot(linearDet,nonLinearDet,".",label="before correction")
plt.plot(linearDet,d,".",label="after correction")
poly_lin = np.polyfit(linearDet,d,1)
xmin = min(linearDet.min(),0)
xtemp = np.asarray( (xmin,linearDet.max()) )
plt.plot(xtemp,np.polyval(poly_lin,xtemp),label="linear fit")
plt.plot(linearDet,d-np.polyval(poly_lin,linearDet),
".",label="difference after-linear")
plt.xlabel("linearDet")
plt.ylabel("nonLinearDet")
plt.legend()
if order>=2 and p[-3]<0:
log.warn("corrNonlinGetPar: consistency problem, second order coefficient should \
be > 0, please double check result (plot=True) or try inverting the data and the\
correct arguments")
if returnCorrectedDet:
return corrNonlin(nonLinearDet,p,data_0=data_0,correct_0=correct_0)
else:
return p
def calib(self, name, mac, channel, vnom,
vmin=None, vmax=None, i2c_command=None):
self.k.output_state(False)
response = raw_input('connect to %s' % name)
if response == ' ' or response == ' ':
return
if not vmin:
vmin = 0.1 * vnom
if not vmax:
vmax = 1.05 * vnom
self.k.select(2)
self.k.set_voltage(keithley_3p3v)
self.k.set_current(0.5)
self.k.output_enable(True)
self.k.select(1)
self.k.set_voltage(vmin)
self.k.set_current(0.1)
self.k.output_enable(True)
self.k.output_state(True)
if i2c_command:
self.eng.call(eng1_mac, 'i2cInit', False)
num = self.eng.call(eng1_mac, 'i2cWrite', i2c_command, 10, False)
print 'num:', num
vtest = vmin
vstep = (vmax - vmin) / (number_of_points - 1)
i = number_of_points
x = []
y = []
while i > 0:
i -= 1
self.k.set_voltage(vtest)
#read_stable(self.k.meas_voltage, 0.005, 4, 10)
#read_stable(self.fluke.get_read, 0.05, 3, 10)
sleep(0.5)
adcs = []
while len(adcs) < 25:
adc = self.eng.call(mac, 'readAdc', channel)
adcs.append(float(adc))
adc = numpy.average(adcs)
stddev = numpy.std(adcs)
#adc = sum(adcs) / len(adcs)
#print 'adc =', adc
vmeas = self.fluke.get_read()
print self.k.set_voltage(), vmeas, adc, stddev
x.append(adc)
y.append(vmeas)
vtest += vstep
p = numpy.polyfit(x, y, 3)
print '%s_poly = %s' % (name, nice_print(p.tolist()))
error = 0.0
i = 0
while i < len(x):
v = numpy.polyval(p, x[i])
e = math.fabs(v - y[i])
if e > error:
error = e
i += 1
print '%s_error_percent = %.3f' % (name, 100.0 * error / vnom)
print '%s_range = (%.3f, %.3f)' % (
name, numpy.polyval(p, 0), numpy.polyval(p, 1023))
def tfit(line):
"""
Correct for temperature systematics. Fit a polynomial to (teff,abund)
and require that the corrected solar value be 0. We cut on vsini,
returns:
(fitabund,fitpar,t,abund)
fitabund - the temperature corrected abundance
fitpar - the parameters to the polynomial fit
t - the temperature array
abund - the non-temp-corrected abundances
"""
deg = 3 # fit with a 3rd degree polynomial
#define abundance for the particular line we're looking at
p = getelnum.Getelnum(line)
elstr = p.elstr
conn = sqlite3.connect(os.environ['STARSDB'])
cur = conn.cursor()
#pull in the abundances and the non-corrected abundances
cmd = 'SELECT '+elstr+'_abund_nt,teff FROM mystars WHERE '+globcut(elstr)
cur.execute(cmd)
arr = np.array(cur.fetchall() )
abund,t = arr[:,0],arr[:,1]
abund = abund - p.abnd_sol
#fit the points
fitpar = np.polyfit(t,abund,deg)
#subtract out the fit, while requiring that the solar value be 0.
fitpar[deg] = fitpar[deg] - np.polyval(fitpar,p.teff_sol)
fitabund = abund - np.polyval(fitpar,t)
return (fitabund,fitpar,t,abund)
def FitLine(self, definition):
'''
Fits a 1st order polynom (line) to the
start and end points of a straight path,
then populates the line with equally spaced
points, and returns the list of points
'''
Ax = self.A.get_Pos_X();
Ay = self.A.get_Pos_Y();
Bx = self.B.get_Pos_X();
By = self.B.get_Pos_Y();
SubWP_No = numpy.linalg.norm(numpy.array([Ax-Bx,Ay-By])) * definition * 0.01;
'''
If the path is vertical, the X and Y axes must be swapped before the
polynom fitting and populating, then switched back to return the
proper point coordinates
'''
if abs(Ax - Bx) < 1:
self.poly = numpy.polyfit([Ay, By], [Ax, Bx], 1);
prange = numpy.linspace(Ay, By, SubWP_No);
values = numpy.polyval(self.poly, prange);
self.SubWP = numpy.array([prange, values]);
else:
self.poly = numpy.polyfit([Ax, Bx], [Ay, By], 1);
prange = numpy.linspace(Ax, Bx, SubWP_No);
values = numpy.polyval(self.poly, prange);
self.SubWP = numpy.array([values, prange]);
def get_spectrum(self,sample_str,x_scale = 'energy'):
#normalize the signals to the tube current
direct_beam = self.scan_groups['direct_beam']
sample = self.scan_groups[sample_str]
theta = direct_beam['signal']['theta']
I0 = direct_beam['signal']['intensity']/direct_beam['signal']['tube_current']
I0_err = direct_beam['signal']['intensity_error']/direct_beam['signal']['tube_current']
I = sample['signal']['intensity']/sample['signal']['tube_current']
I_err = sample['signal']['intensity_error']/sample['signal']['tube_current']
theta_I0bg = direct_beam['background']['theta']
theta_Ibg = sample['background']['theta']
I0_bg = direct_beam['background']['intensity']/direct_beam['background']['tube_current']
I_bg = sample['background']['intensity']/sample['background']['tube_current']
#fit backgrounds
p0 = np.polyfit(theta_I0bg,I0_bg,self.background_fit_order)
p = np.polyfit(theta_Ibg,I_bg,self.background_fit_order)
#compute mux
mux = -np.log((I-np.polyval(p,theta))/(I0-np.polyval(p0,theta)))
mux_error = np.sqrt((I0_err/I0)**2 + (I_err/I)**2)
if x_scale == 'theta':
return theta+self.theta_calibration, mux, mux_error
else:
return energy(theta+self.theta_calibration,*self.analyser), mux, mux_error
def _precess_from_J2000_Capitaine(epoch):
"""
Computes the precession matrix from J2000 to the given Julian Epoch.
Expression from from Capitaine et al. 2003 as expressed in the USNO
Circular 179. This should match the IAU 2006 standard from SOFA.
Parameters
----------
epoch : scalar
The epoch as a julian year number (e.g. J2000 is 2000.0)
"""
from .angles import rotation_matrix
T = (epoch - 2000.0) / 100.0
# from USNO circular
pzeta = (-0.0000003173, -0.000005971, 0.01801828, 0.2988499, 2306.083227, 2.650545)
pz = (-0.0000002904, -0.000028596, 0.01826837, 1.0927348, 2306.077181, -2.650545)
ptheta = (-0.0000001274, -0.000007089, -0.04182264, -0.4294934, 2004.191903, 0)
zeta = np.polyval(pzeta, T) / 3600.0
z = np.polyval(pz, T) / 3600.0
theta = np.polyval(ptheta, T) / 3600.0
return rotation_matrix(-z, 'z') *\
rotation_matrix(theta, 'y') *\
rotation_matrix(-zeta, 'z')
def _precession_matrix_besselian(epoch1, epoch2):
"""
computes the precession matrix from one Besselian epoch to another using
Newcomb's method.
`epoch1` and `epoch2` are in besselian year numbers
"""
from .angles import rotation_matrix
# tropical years
t1 = (epoch1 - 1850.0) / 1000.0
t2 = (epoch2 - 1850.0) / 1000.0
dt = t2 - t1
zeta1 = 23035.545 + t1 * 139.720 + 0.060 * t1 * t1
zeta2 = 30.240 - 0.27 * t1
zeta3 = 17.995
pzeta = (zeta3, zeta2, zeta1, 0)
zeta = np.polyval(pzeta, dt) / 3600
z1 = 23035.545 + t1 * 139.720 + 0.060 * t1 * t1
z2 = 109.480 + 0.39 * t1
z3 = 18.325
pz = (z3, z2, z1, 0)
z = np.polyval(pz, dt) / 3600
theta1 = 20051.12 - 85.29 * t1 - 0.37 * t1 * t1
theta2 = -42.65 - 0.37 * t1
theta3 = -41.8
ptheta = (theta3, theta2, theta1, 0)
theta = np.polyval(ptheta, dt) / 3600
return rotation_matrix(-z, 'z') *\
rotation_matrix(theta, 'y') *\
rotation_matrix(-zeta, 'z')
def unravel_box(self, box):
"""Convert a rectangular represenation of the spectra back to a single
array
Parameters
----------
box: ~numpy.ndarray
Rectangular represnation of flux
Returns
-------
data: ~numpy.ndarray
Array of values to convert into a rectangular representation
"""
xmax = self.region[1].max()
xmin = 0
ymax = self.region[0].max()
ymin = self.region[0].min()
ys = ymax-ymin
xs = xmax-xmin
data = np.zeros((ys+1,xs+1))
coef = np.polyfit(self.region[1], self.region[0], 3)
xarr = np.arange(xs+1)
yarr = np.polyval(coef, xarr)-ymin
x = self.region[1]-xmin
y = self.region[0]-ymin - (np.polyval(coef, x) - ymin - yarr.min()).astype(int)
data = np.zeros(self.npixels)
data = box[y,x]
return data
def update(self, rho):
"""
Calculate the probability function for the given state of an harmonic
oscillator (as density matrix)
"""
if isket(rho):
rho = ket2dm(rho)
self.data = np.zeros(len(self.xvecs[0]), dtype=complex)
M, N = rho.shape
for m in range(M):
k_m = pow(self.omega / pi, 0.25) / \
sqrt(2 ** m * factorial(m)) * \
exp(-self.xvecs[0] ** 2 / 2.0) * \
np.polyval(hermite(m), self.xvecs[0])
for n in range(N):
k_n = pow(self.omega / pi, 0.25) / \
sqrt(2 ** n * factorial(n)) * \
exp(-self.xvecs[0] ** 2 / 2.0) * \
np.polyval(hermite(n), self.xvecs[0])
self.data += np.conjugate(k_n) * k_m * rho.data[m, n]
def get_cont(x,y,n=1,sl=1.,sh=5.): orilen = len(x) coef = np.polyfit(x,y,n) res = y - np.polyval(coef,x) IH = np.where(res>0)[0] IL = np.where(res<0)[0] dev = np.mean(res[IH]) I = np.where((res>-sl*dev) & (res<sh*dev))[0] J1 = np.where(res<=-sl*dev)[0] J2 = np.where(res>=sh*dev)[0] J = np.unique(np.hstack((J1,J2))) cond = True if len(J)==0 or len(x)< .3*orilen: cond=False while cond: x = np.delete(x,J) y = np.delete(y,J) coef = np.polyfit(x,y,n) res = y - np.polyval(coef,x) IH = np.where(res>0)[0] IL = np.where(res<0)[0] dev = np.mean(res[IH]) I = np.where((res>-sl*dev) & (res<sh*dev))[0] J1 = np.where(res<=-sl*dev)[0] J2 = np.where(res>=sh*dev)[0] J = np.unique(np.hstack((J1,J2))) cond = True if len(J)==0 or len(x)< .1*orilen: cond=False return coef
def get_ratio(sciw,rat,n=3): rat = scipy.signal.medfilt(rat,11) lori = len(sciw) coef = np.polyfit(sciw,rat,n) res = rat - np.polyval(coef,sciw) rms = np.sqrt(np.mean(res**2)) I = np.where(res> 3*rms)[0] I2 = np.where(res< -3*rms)[0] I = np.sort(np.hstack((I,I2))) cond = True if len(I) == 0 or len(sciw) < .3 * lori: cond = False while cond: #imax = np.argmax(res**2) #sciw = np.delete(sciw,imax) #rat = np.delete(rat,imax) sciw = np.delete(sciw,I) rat = np.delete(rat,I) coef = np.polyfit(sciw,rat,n) res = rat - np.polyval(coef,sciw) rms = np.sqrt(np.mean(res**2)) I = np.where(res> 3*rms)[0] I2 = np.where(res< -3*rms)[0] I = np.sort(np.hstack((I,I2))) if len(I) == 0 or len(sciw) < .3 * lori: cond = False return coef
def detrend(var, ax=None, lcopy=True, ldetrend=True, ltrend=False, degree=1, rcond=None, w=None,
lsmooth=False, lresidual=False, window_len=11, window='hanning'):
''' subtract a linear trend from a time-series array (operation is in-place) '''
# check input
if not isinstance(var,np.ndarray): raise NotImplementedError # too many checks
if lcopy: var = var.copy() # make copy - not in-place!
# fit over entire array (usually not what we want...)
if ax is None and ldetrend: ax = np.arange(var.size) # make dummy axis, if necessary
if var.ndim != 1:
shape = var.shape
var = var.ravel() # flatten array, if necessary
else: shape = None
# apply optional detrending
if ldetrend or ltrend:
# fit linear trend
trend = np.polyfit(ax, var, deg=degree, rcond=rcond, w=w, full=False, cov=False)
# evaluate and subtract linear trend
if ldetrend and ltrend: raise ArgumentError("Can either return trend/polyfit or residuals, not both.")
elif ldetrend and not ltrend: var -= np.polyval(trend, ax) # residuals
elif ltrend and not ldetrend: var = np.polyval(trend, ax) # residuals
# apply optional smoothing
if lsmooth and lresidual: raise ArgumentError("Can either return smoothed array or residuals, not both.")
elif lsmooth: var = smooth(var, window_len=window_len, window=window)
elif lresidual: var -= smooth(var, window_len=window_len, window=window)
# return detrended and/or smoothed time-series
if shape is not None: var = var.reshape(shape)
return var
def get_rats(ZO,ZI,ZF,pars):
ords = []
for i in range(sc.shape[1]):
J1 = np.where(mw > sc[0,i,-1])[0]
J2 = np.where(mw < sc[0,i,0])[0]
if len(J1)>0 and len(J2)>0:
ords.append(i)
ords = np.array(ords)
mf = get_full_model(pars[0],pars[1],pars[2],pars[3],RES_POW)
tmodf = np.zeros((sc.shape[1],sc.shape[2]))
tscif = np.zeros((sc.shape[1],sc.shape[2]))
test_plot = np.zeros((4,sc.shape[1],sc.shape[2]))
for i in ords:
I = np.where((mw>sc[0,i,0]) & (mw<sc[0,i,-1]))[0]
modw = mw[I]
modf = mf[I]
sciw = sc[0,i]
scif = sc[3,i]/np.median(sc[3,i])
modf = pixelization(modw,modf,sciw)
#IMB = np.where(mask_bin[i]!=0)[0]
#modf /= modf[IMB].mean()
mscif = scipy.signal.medfilt(scif,11)
rat = modf/mscif
INF = np.where(mscif!=0)[0]
coef = get_ratio(sciw[INF],rat[INF])
scif = scif * np.polyval(coef,sciw)
mscif = mscif * np.polyval(coef,sciw)
coef = get_cont(sciw,mscif)
scif = scif / np.polyval(coef,sciw)
#plot(sciw,scif)
coef = get_cont(sciw,modf)
modf = modf / np.polyval(coef,sciw)
#plot(sciw,modf)
tmodf[i] = modf
tscif[i] = scif
test_plot[0,i] = sc[0,i]
test_plot[1,i] = scif
test_plot[2,i] = modf
test_plot[3,i] = mask_bin[i]
#show()
#print vcdx
hdu = pyfits.PrimaryHDU(test_plot)
os.system('rm example.fits')
hdu.writeto('example.fits')
rat = tscif/tmodf
nejx = np.arange(100)/100.
ratsout = []
for i in range(len(ZI)):
ejy = rat[ZO[i],ZI[i]:ZF[i]]
ejx = np.arange(len(ejy))/float(len(ejy))
tck = interpolate.splrep(ejx,ejy,k=3)
if len(ratsout)==0:
ratsout = interpolate.splev(nejx,tck)
else:
ratsout = np.vstack((ratsout,interpolate.splev(nejx,tck)))
#plot(interpolate.splev(nejx,tck))
#show()
return ratsout
def rssmodelwave(grating,grang,artic,cbin,cols):
# compute wavelengths from model (this can probably be done using pyraf spectrograph model)
spec=np.loadtxt(datadir+"spec.txt",usecols=(1,))
Grat0,Home0,ArtErr,T2Con,T3Con=spec[0:5]
FCampoly=spec[5:11]
grname=np.loadtxt(datadir+"gratings.txt",dtype=str,usecols=(0,))
grlmm,grgam0=np.loadtxt(datadir+"gratings.txt",usecols=(1,2),unpack=True)
grnum = np.where(grname==grating)[0][0]
lmm = grlmm[grnum]
alpha_r = np.radians(grang+Grat0)
beta0_r = np.radians(artic*(1+ArtErr)+Home0)-alpha_r
gam0_r = np.radians(grgam0[grnum])
lam0 = 1e7*np.cos(gam0_r)*(np.sin(alpha_r) + np.sin(beta0_r))/lmm
ww = lam0/1000. - 4.
fcam = np.polyval(FCampoly,ww)
disp = (1e7*np.cos(gam0_r)*np.cos(beta0_r)/lmm)/(fcam/.015)
dfcam = 3.162*disp*np.polyval([FCampoly[x]*(5-x) for x in range(5)],ww)
T2 = -0.25*(1e7*np.cos(gam0_r)*np.sin(beta0_r)/lmm)/(fcam/47.43)**2 + T2Con*disp*dfcam
T3 = (-1./24.)*3162.*disp/(fcam/47.43)**2 + T3Con*disp
T0 = lam0 + T2
T1 = 3162.*disp + 3*T3
X = (np.array(range(cols))+1-cols/2)*cbin/3162.
lam_X = T0+T1*X+T2*(2*X**2-1)+T3*(4*X**3-3*X)
return lam_X
def dualPlot(age, meanWithin, meanBetween, title):
fig, (within, between) = plt.subplots(1, 2, sharex=True, sharey=False)
# fitshit
wP = np.polyfit(age, meanWithin, 1)
bP = np.polyfit(age, meanBetween, 1)
xnew = np.arange(age.min() - 1, age.max() + 1, 0.1)
wFit = np.polyval(wP, xnew)
bFit = np.polyval(bP, xnew)
within.set_title("within network")
between.set_title("between network")
withinCorr, withinP = st.pearsonr(age, meanWithin)
within.plot(age, meanWithin, "k.")
within.plot(xnew, wFit, "r", label=(str(np.round(withinCorr, 2)) + " " + str(np.round(withinP, 4))))
within.set_xlabel("mean connectivity")
within.set_ylabel("age")
within.legend()
betweenCorr, betweenP = st.pearsonr(age, meanBetween)
between.plot(age, meanBetween, "k.")
between.plot(xnew, bFit, "b", label=(str(np.round(betweenCorr, 2)) + " " + str(np.round(betweenP, 4))))
between.set_xlabel("mean connectivity")
between.set_ylabel("age")
between.legend()
fig.suptitle(title)
plt.show()
raw_input("Press Enter to continue...")
plt.close()
def eeval(expression, w): """ evaluate a sympy expression at omega. return magnitude, phase.""" num, den = e2nd(expression) y = numpy.polyval(num, 1j*w) / numpy.polyval(den, 1j*w) phase = numpy.arctan2(y.imag, y.real) * 180.0 / numpy.pi mag = abs(y) return mag, phase
def get_line_points(self):
y = np.array(range(0, self.img_size[1]+1, 10), dtype=np.float32)/self.pixels_per_meter[1]
x = np.polyval(self.poly_coeffs, y)*self.pixels_per_meter[0]
y *= self.pixels_per_meter[1]
return np.array([x, y], dtype=np.int32).T
def polyinterp(points, x_min_bound=None, x_max_bound=None, plot=False):
"""
Gives the minimizer and minimum of the interpolating polynomial over given points
based on function and derivative information. Defaults to bisection if no critical
points are valid.
Based on polyinterp.m Matlab function in minFunc by Mark Schmidt with some slight
modifications.
Implemented by: Hao-Jun Michael Shi and Dheevatsa Mudigere
Last edited 12/6/18.
Inputs:
points (nparray): two-dimensional array with each point of form [x f g]
x_min_bound (float): minimum value that brackets minimum (default: minimum of points)
x_max_bound (float): maximum value that brackets minimum (default: maximum of points)
plot (bool): plot interpolating polynomial
Outputs:
x_sol (float): minimizer of interpolating polynomial
F_min (float): minimum of interpolating polynomial
Note:
. Set f or g to np.nan if they are unknown
"""
no_points = points.shape[0]
order = np.sum(1 - np.isnan(points[:, 1:3]).astype('int')) - 1
x_min = np.min(points[:, 0])
x_max = np.max(points[:, 0])
# compute bounds of interpolation area
if x_min_bound is None:
x_min_bound = x_min
if x_max_bound is None:
x_max_bound = x_max
# explicit formula for quadratic interpolation
if no_points == 2 and order == 2 and plot is False:
# Solution to quadratic interpolation is given by:
# a = -(f1 - f2 - g1(x1 - x2))/(x1 - x2)^2
# x_min = x1 - g1/(2a)
# if x1 = 0, then is given by:
# x_min = - (g1*x2^2)/(2(f2 - f1 - g1*x2))
if points[0, 0] == 0:
x_sol = -points[0, 2] * points[1, 0]**2 / (
2 *
(points[1, 1] - points[0, 1] - points[0, 2] * points[1, 0]))
else:
a = -(points[0, 1] - points[1, 1] - points[0, 2] *
(points[0, 0] - points[1, 0])) / (points[0, 0] -
points[1, 0])**2
x_sol = points[0, 0] - points[0, 2] / (2 * a)
x_sol = np.minimum(np.maximum(x_min_bound, x_sol), x_max_bound)
# explicit formula for cubic interpolation
elif no_points == 2 and order == 3 and plot is False:
# Solution to cubic interpolation is given by:
# d1 = g1 + g2 - 3((f1 - f2)/(x1 - x2))
# d2 = sqrt(d1^2 - g1*g2)
# x_min = x2 - (x2 - x1)*((g2 + d2 - d1)/(g2 - g1 + 2*d2))
d1 = points[0, 2] + points[1, 2] - 3 * ((points[0, 1] - points[1, 1]) /
(points[0, 0] - points[1, 0]))
d2 = np.sqrt(d1**2 - points[0, 2] * points[1, 2])
if np.isreal(d2):
x_sol = points[1, 0] - (points[1, 0] - points[0, 0]) * (
(points[1, 2] + d2 - d1) /
(points[1, 2] - points[0, 2] + 2 * d2))
x_sol = np.minimum(np.maximum(x_min_bound, x_sol), x_max_bound)
else:
x_sol = (x_max_bound + x_min_bound) / 2
# solve linear system
else:
# define linear constraints
A = np.zeros((0, order + 1))
b = np.zeros((0, 1))
# add linear constraints on function values
for i in range(no_points):
if not np.isnan(points[i, 1]):
constraint = np.zeros((1, order + 1))
for j in range(order, -1, -1):
constraint[0, order - j] = points[i, 0]**j
A = np.append(A, constraint, 0)
b = np.append(b, points[i, 1])
# add linear constraints on gradient values
for i in range(no_points):
if not np.isnan(points[i, 2]):
constraint = np.zeros((1, order + 1))
for j in range(order):
constraint[0,
j] = (order - j) * points[i, 0]**(order - j - 1)
A = np.append(A, constraint, 0)
b = np.append(b, points[i, 2])
# check if system is solvable
if A.shape[0] != A.shape[1] or np.linalg.matrix_rank(A) != A.shape[0]:
x_sol = (x_min_bound + x_max_bound) / 2
f_min = np.Inf
else:
# solve linear system for interpolating polynomial
coeff = np.linalg.solve(A, b)
# compute critical points
dcoeff = np.zeros(order)
for i in range(len(coeff) - 1):
dcoeff[i] = coeff[i] * (order - i)
crit_pts = np.array([x_min_bound, x_max_bound])
crit_pts = np.append(crit_pts, points[:, 0])
if not np.isinf(dcoeff).any():
roots = np.roots(dcoeff)
crit_pts = np.append(crit_pts, roots)
# test critical points
f_min = np.Inf
x_sol = (x_min_bound + x_max_bound) / 2 # defaults to bisection
for crit_pt in crit_pts:
if np.isreal(
crit_pt
) and crit_pt >= x_min_bound and crit_pt <= x_max_bound:
F_cp = np.polyval(coeff, crit_pt)
if np.isreal(F_cp) and F_cp < f_min:
x_sol = np.real(crit_pt)
f_min = np.real(F_cp)
if (plot):
plt.figure()
x = np.arange(x_min_bound, x_max_bound,
(x_max_bound - x_min_bound) / 10000)
f = np.polyval(coeff, x)
plt.plot(x, f)
plt.plot(x_sol, f_min, 'x')
return x_sol
if src.get_jys()[0] < .01: continue
uv = a.miriad.UV(filename)
dat = []
x,y,z = [],[],[]
for (crd,t,bl),d,f in uv.all(raw=True):
if f[ch]: continue
aa.set_jultime(t)
src.compute(aa)
if src.alt < opts.altmin * a.img.deg2rad: continue
xi,yi,zi = src.get_crds('top', ncrd=3)
x.append(xi); y.append(yi); z.append(zi)
dat.append(d[ch])
sdat = n.abs(n.array(dat))
x,y,z = n.array(x), n.array(y), n.array(z)
poly = n.polyfit(x, sdat, deg=6)
sig = n.sqrt(n.average((sdat - n.polyval(poly, x))**2))
jys = src.get_jys()[0]
src_dat[src_name] = (x,y,z,sdat,jys,sig)
#prms[src_name] = pymc.Normal(src_name, jys, 1./sig**2)
prms[src_name] = jys
#print src_name, src_dat[src_name][-2:]
#@pymc.deterministic
def infer_hmap(arg=prms):
alms = a.healpix.Alm(opts.lmax,opts.lmax)
_hmapr = a.healpix.HealpixMap(hmap.nside(), dtype=n.float)
_hmapi = a.healpix.HealpixMap(hmap.nside(), dtype=n.float)
_alm = a.healpix.Alm(opts.lmax,opts.lmax)
for L,M in zip(*alms.lm_indices()):
_alm.set_to_zero()
_alm[L,M] = 1.0
def normalize_img(img, com, size):
"""Mask off the atoms, then fit linear slopes to the image and normalize
We assume that there are no atoms left outside 1.5 times the size. This
seems to be a reasonable assumption, it does not influence the result of
the normalization.
**Inputs**
* img: 2D array, containing the image
* com: tuple, center of mass coordinates
* size: float, radial size of the cloud
**Outputs**
* normimg: 2D array, the normalized image
"""
xmax, ymax = img.shape
# create mask
x_ind1 = round(com[0] - 1.5 * size)
x_ind2 = round(com[0] + 1.5 * size)
y_ind1 = round(com[1] - 1.5 * size)
y_ind2 = round(com[1] + 1.5 * size)
# fit first order polynomial along x and y (do not use quadratic terms!!)
if x_ind1 > 0 and x_ind2 < xmax and y_ind1 > 0 and y_ind2 < ymax:
normx = np.zeros(x_ind1 + xmax - x_ind2, dtype=float)
xx = np.ones(normx.shape)
xx[:x_ind1] = np.arange(x_ind1)
xx[x_ind1:] = np.arange(x_ind2, xmax)
normx[:x_ind1] = img[:x_ind1, :].mean(axis=1)
normx[x_ind1:] = img[x_ind2:, :].mean(axis=1)
# fit normx vs xx
fitline = np.polyfit(xx, normx, 1)
divx = np.ones(img.shape, dtype=float).transpose()*\
np.polyval(fitline, np.arange(img.shape[0])).transpose()
normimg = img / divx.transpose()
normy = np.zeros(y_ind1 + ymax - y_ind2, dtype=float)
yy = np.ones(normy.shape)
yy[:y_ind1] = np.arange(y_ind1)
yy[y_ind1:] = np.arange(y_ind2, ymax)
normy[:y_ind1] = normimg[:, :y_ind1].mean(axis=0)
normy[y_ind1:] = normimg[:, y_ind2:].mean(axis=0)
# fit normx vs yy
fitline = np.polyfit(yy, normy, 1)
divy = np.ones(normimg.shape, dtype=float)*\
np.polyval(fitline, np.arange(normimg.shape[1]))
normimg = normimg / divy
else:
print "atom cloud extends to the edge of the image, can't normalize"
raise NotImplementedError
return normimg
pylab.title("Model is" + "\n" + "r^2 = " + str(r_square))
pylab.xlabel("Year")
pylab.ylabel("Temperature")
pylab.legend()
### Begining of program
raw_data = Climate('data.csv')
## Problem 3
y = []
x = INTERVAL_1
for year in INTERVAL_1:
y.append(raw_data.get_daily_temp('BOSTON', 1, 10, year))
models = generate_models(x, y, [1])
evaluate_models_on_training(x, y, models)
estimated = np.polyval(models[0], x)
r_square = r_squared(y, estimated)
print(r_square)
## Problem 4: FILL IN MISSING CODE TO GENERATE y VALUES
x1 = INTERVAL_1
x2 = INTERVAL_2
y = []
for year in INTERVAL_1:
y.append(np.mean(raw_data.get_yearly_temp('BOSTON', year)))
models = generate_models(x, y, [1])
evaluate_models_on_training(x, y, models)
#dax['PCA_2'] = np.dot(pca_components, weights) #가중평균으로 계산
# 다섯 개 주성분이 나오도록 분석
pca = KernelPCA(n_components=5).fit(data.apply(scale_function))
pca_components = pca.transform(data)
weights = get_we(pca.lambdas_) #다섯 개의 주성분 비중을 정규화
dax['PCA_5'] = np.dot(pca_components, weights) #가중평균으로 계산
#dax.apply(scale_function).plot(figsize=(8, 4))
mpl_dates = mpl.dates.date2num(data.index.to_pydatetime())
plt.figure(figsize=(8,4))
plt.scatter(dax['PCA_5'], dax['^GDAXI'], c=mpl_dates, s=np.repeat(6, len(dax)))
lin_reg = np.polyval(np.polyfit(dax['PCA_5'], dax['^GDAXI'], 1), dax['PCA_5'])
plt.plot(dax['PCA_5'], lin_reg, 'r', lw=3)
plt.grid(True)
plt.xlabel('PCA_5')
plt.ylabel('^GDAXI')
plt.colorbar(ticks=mpl.dates.DayLocator(interval=250),
format=mpl.dates.DateFormatter('%d %b %y'))
# 각각의 연결된 선 하나가 하나의 회귀모형으로 최대한 만족할 수 있는 구간으로 해석
cut_date = '2011/7/1'
early_pca = dax[dax.index < cut_date]['PCA_5']
print(len(early_pca))
print(len(dax['^GDAXI'][dax.index < cut_date]))
early_reg = np.polyval(np.polyfit(early_pca, dax['^GDAXI'][dax.index < cut_date], 1), early_pca)
def compute_profile(wl, img, line_wl, line_width=5, n_iter=15, polyorder=5,
bad_rows=None, debug=False,
op=numpy.sum):
y,x = numpy.indices(wl.shape)
#print wl.shape, img.shape
#fits.PrimaryHDU(data=x).writeto("fiddle_x.fits", clobber=True)
#fits.PrimaryHDU(data=y).writeto("fiddle_y.fits", clobber=True)
logger = logging.getLogger("ComputeProfile")
logger.debug("Using measurement operation: %s" % (str(op)))
if (debug):
region_select = img.copy()
full_select = (wl >= line_wl-line_width) & (wl <= line_wl+line_width)
region_select[bad_rows.reshape((-1,1))] = numpy.NaN
region_select[~full_select] = numpy.NaN
fits.PrimaryHDU(data=region_select).writeto(
"slitflat_data_%.f.fits" % (line_wl), clobber=True,
)
if (bad_rows is not None):
wl = wl[~bad_rows, :]
img = img[~bad_rows, :]
y = y[~bad_rows, :]
x = x[~bad_rows, :]
part_of_line = (wl >= line_wl-line_width) & (wl <= line_wl+line_width)
# if (debug):
# full_select = part_of_line[~bad_rows]
# region_select[bad_rows] = numpy.NaN
# region_select[~bad_rows][~part_of_line] = numpy.NaN
#
cut_wl = wl[part_of_line]
cut_y = y[part_of_line]
cut_img = img[part_of_line]
if (numpy.isnan(cut_img).any()):
# there are invalid pixels in this bin - be safe and not use this data at all
logger.debug("found at least one pixel with NaN - skipping this data set")
return None, None
#print cut_wl.shape, cut_y.shape, cut_img.shape
combined = numpy.empty((cut_wl.shape[0], 4))
combined[:,0] = cut_wl
combined[:,1] = x[part_of_line]
combined[:,2] = cut_y
combined[:,3] = cut_img
if (debug):
out_fn = "fiddle_slitflat.comb.%7.2f-%.2f" % (line_wl, line_width)
numpy.savetxt(out_fn, combined)
numpy.save(out_fn, combined)
#print out_fn
# print "WL shape:", wl.shape
output = numpy.empty((wl.shape[0],20))
output[:,:] = numpy.NaN
# print y
# print y[:,0]
for iy in range(wl.shape[0]):
#if (bad_rows is not None and bad_rows[iy]):
# continue
wl_match = (wl[iy,:] >= line_wl-line_width) & (wl[iy,:] <= line_wl+line_width)
# find line intensity
flux = op(img[iy, wl_match])
output[iy,0] = y[iy,0] #iy
output[iy,1] = flux
#
# run a median filter to get rid of individual hot pixels
#
logger.debug("median-filtering the line profile to eliminate hot pixels and cosmics")
fm = scipy.ndimage.median_filter(output[:,1], size=25, mode='constant', cval=0)
output[:,2] = fm
_median = numpy.nanmedian(output[:,1])
# output[:,1][bad_rows] = _median
# fm = scipy.ndimage.median_filter(output[:,1], size=25, mode='constant', cval=0)
# output[:,2] = fm
# print "output shape:", output.shape
valid = numpy.isfinite(fm)
fm[~valid] = -1e99 # this is to prevent runtimewarnings about invalid values encountered
median_intensity = numpy.median(fm[valid])
valid &= (fm > 0.3*median_intensity)
# print "valid", valid.shape
if (debug):
out_fn = "fiddle_slitflat.comb2.%7.2f-%.2f" % (line_wl, line_width)
# print out_fn
with open(out_fn, "w") as f:
numpy.savetxt(f, output)
print >>f, "\n"*5
#print out_fn2
# print output[:,0][valid]
# print output[:,2][valid]
# print "fm:", fm.shape
fit, poly = None, None
for iteration in range(n_iter):
try:
poly = numpy.polyfit(
x=output[:,0][valid],
y=output[:,2][valid],
deg=polyorder,
)
except Exception as e:
print e
break
fit = numpy.polyval(poly, output[:,0])
residual = fm - fit
_perc = numpy.nanpercentile(residual[valid], [16,84,50])
_med = _perc[2]
_sigma = 0.5*(_perc[1] - _perc[0])
#print _sigma, _perc
bad = (residual > 3*_sigma) | (residual < -3*_sigma)
valid[bad] = False
output[:,iteration+3] = fit
norm_line = int(0.5*output.shape[0])
output[:,n_iter+3] = output[:,n_iter+2] / output[norm_line,n_iter+2]
if (debug):
out_fn = "fiddle_slitflat.comb2.%7.2f-%.2f" % (line_wl, line_width)
with open(out_fn, "w") as f:
numpy.savetxt(f, output)
print >>f, "\n"*5
#print out_fn2
# print "done with fitting one wl profile"
return fit, poly
def synthesize_spectrum(
sme,
segments="all",
passLineList=True,
passAtmosphere=True,
passNLTE=True,
reuse_wavelength_grid=False,
):
"""
Calculate the synthetic spectrum based on the parameters passed in the SME structure
The wavelength range of each segment is set in sme.wran
The specific wavelength grid is given by sme.wave, or is generated on the fly if sme.wave is None
Will try to fit radial velocity RV and continuum to observed spectrum, depending on vrad_flag and cscale_flag
Other important fields:
sme.iptype: instrument broadening type
Parameters
----------
sme : SME_Struct
sme structure, with all necessary parameters for the calculation
setLineList : bool, optional
wether to pass the linelist to the c library (default: True)
passAtmosphere : bool, optional
wether to pass the atmosphere to the c library (default: True)
passNLTE : bool, optional
wether to pass NLTE departure coefficients to the c library (default: True)
reuse_wavelength_grid : bool, optional
wether to use sme.wint as the output grid of the function or create a new grid (default: False)
Returns
-------
sme : SME_Struct
same sme structure with synthetic spectrum in sme.smod
"""
# Define constants
n_segments = sme.nseg
nmu = sme.nmu
cscale_degree = sme.cscale_degree
# fix impossible input
if "spec" not in sme:
sme.vrad_flag = "none"
if "spec" not in sme:
sme.cscale_flag = "none"
if "wint" not in sme:
reuse_wavelength_grid = False
if segments == "all":
segments = range(n_segments)
else:
segments = np.atleast_1d(segments)
if np.any(segments < 0) or np.any(segments >= n_segments):
raise IndexError("Segment(s) out of range")
# Prepare arrays
wran = sme.wran
wint = [None for _ in range(n_segments)]
sint = [None for _ in range(n_segments)]
cint = [None for _ in range(n_segments)]
vrad = np.zeros(n_segments)
cscale = np.zeros((n_segments, cscale_degree + 1))
cscale[:, -1] = 1
wave = [None for _ in range(n_segments)]
smod = [[] for _ in range(n_segments)]
wmod = [[] for _ in range(n_segments)]
wind = np.zeros(n_segments + 1, dtype=int)
# If wavelengths are already defined use those as output
if "wave" in sme:
wave = [w for w in sme.wave]
wind = [0, *np.diff(sme.wind)]
# Input Model data to C library
if passLineList and not reuse_wavelength_grid:
dll.SetLibraryPath()
dll.InputLineList(sme.linelist)
if passAtmosphere:
sme = get_atmosphere(sme)
dll.InputModel(sme.teff, sme.logg, sme.vmic, sme.atmo)
dll.InputAbund(sme.abund)
dll.Ionization(0)
dll.SetVWscale(sme.gam6)
dll.SetH2broad(sme.h2broad)
if passNLTE:
update_nlte_coefficients(sme, dll)
# Loop over segments
# Input Wavelength range and Opacity
# Calculate spectral synthesis for each
# Interpolate onto geomspaced wavelength grid
# Apply instrumental and turbulence broadening
for il in segments:
logging.debug("Segment %i", il)
# Input Wavelength range and Opacity
vrad_seg = sme.vrad[il]
wbeg, wend = get_wavelengthrange(wran[il], vrad_seg, sme.vsini)
dll.InputWaveRange(wbeg, wend)
dll.Opacity()
# Reuse adaptive wavelength grid in the jacobians
wint_seg = sme.wint[il] if reuse_wavelength_grid else None
# Only calculate line opacities in the first segment
keep_line_opacity = il != segments[0]
# Calculate spectral synthesis for each
_, wint[il], sint[il], cint[il] = dll.Transf(
sme.mu,
sme.accrt, # threshold line opacity / cont opacity
sme.accwi,
keep_lineop=keep_line_opacity,
wave=wint_seg,
)
# Create new geomspaced wavelength grid, to be used for intermediary steps
wgrid, vstep = new_wavelength_grid(wint[il])
# Continuum
# rtint = Radiative Transfer Integration
cont_flux = integrate_flux(sme.mu, cint[il], 1, 0, 0)
cont_flux = np.interp(wgrid, wint[il], cont_flux)
# Broaden Spectrum
y_integrated = np.empty((nmu, len(wgrid)))
for imu in range(nmu):
y_integrated[imu] = np.interp(wgrid, wint[il], sint[il][imu])
# Turbulence broadening
# Apply macroturbulent and rotational broadening while integrating intensities
# over the stellar disk to produce flux spectrum Y.
flux = integrate_flux(sme.mu, y_integrated, vstep, sme.vsini, sme.vmac)
# instrument broadening
if "iptype" in sme:
ipres = sme.ipres if np.size(sme.ipres) == 1 else sme.ipres[il]
flux = broadening.apply_broadening(
ipres, wgrid, flux, type=sme.iptype, sme=sme
)
# Divide calculated spectrum by continuum
if sme.cscale_flag != "fix":
flux /= cont_flux
smod[il] = flux
wmod[il] = wgrid
# Create a wavelength array if it doesn't exist
if "wave" not in sme or len(sme.wave[il]) == 0:
# trim padding
wbeg, wend = wran[il]
itrim = (wgrid > wbeg) & (wgrid < wend)
# Force endpoints == wavelength range
wave[il] = np.concatenate(([wbeg], wgrid[itrim], [wend]))
wind[il + 1] = len(wave[il])
# Fit continuum and radial velocity
# And interpolate the flux onto the wavelength grid
cscale, vrad = match_rv_continuum(sme, segments, wmod, smod)
logging.debug("Radial velocity: %s", str(vrad))
logging.debug("Continuum coefficients: %s", str(cscale))
for il in segments:
if vrad[il] is not None:
rv_factor = np.sqrt((1 + vrad[il] / clight) / (1 - vrad[il] / clight))
wmod[il] *= rv_factor
smod[il] = safe_interpolation(wmod[il], smod[il], wave[il])
if cscale[il] is not None and not np.all(cscale[il] == 0):
x = wave[il] - wave[il][0]
smod[il] *= np.polyval(cscale[il], x)
# Merge all segments
# if sme already has a wavelength this should be the same
sme.wind = wind = np.cumsum(wind)
sme.wint = wint
if "wave" not in sme:
npoints = sum([len(wave[s]) for s in segments])
sme.wave = np.zeros(npoints)
if "synth" not in sme:
sme.smod = np.zeros_like(sme.wob)
for s in segments:
sme.wave[s] = wave[s]
sme.synth[s] = smod[s]
if sme.cscale_flag != "fix":
for s in segments:
sme.cscale[s] = cscale[s]
sme.vrad = np.asarray(vrad)
sme.nlte.flags = dll.GetNLTEflags()
return sme
# Airy function
x = np.linspace(-15, 4, 256)
ai, aip, bi, bip = scipy.special.airy(x)
ax[1, 1].plot(x, ai, color='black')
ax[1, 1].plot(x, bi, color='black', dashes=(5, 2))
ax[1, 1].axhline(color="grey", ls="--", zorder=-1)
ax[1, 1].axvline(color="grey", ls="--", zorder=-1)
ax[1, 1].set_xlim(-15, 4)
ax[1, 1].set_ylim(-0.5, 0.6)
ax[1, 1].text(0.5, 0.95, 'Airy', ha='center',
va='top', transform=ax[1, 1].transAxes)
# Legendre polynomials
x = np.linspace(-1, 1, 256)
lp0 = np.polyval(scipy.special.legendre(0), x)
lp1 = np.polyval(scipy.special.legendre(1), x)
lp2 = scipy.special.eval_legendre(2, x)
lp3 = scipy.special.eval_legendre(3, x)
ax[2, 0].plot(x, lp0, color='black')
ax[2, 0].plot(x, lp1, color='black', dashes=(5, 2))
ax[2, 0].plot(x, lp2, color='black', dashes=(3, 2))
ax[2, 0].plot(x, lp3, color='black', dashes=(1, 2))
ax[2, 0].axhline(color="grey", ls="--", zorder=-1)
ax[2, 0].axvline(color="grey", ls="--", zorder=-1)
ax[2, 0].set_ylim(-1, 1.1)
ax[2, 0].text(0.5, 0.9, 'Legendre', ha='center',
va='top', transform=ax[2, 0].transAxes)
# Laguerre polynomials
x = np.linspace(-5, 8, 256)
def get_center_shift(coeffs, img_size, pixels_per_meter):
return np.polyval(coeffs, img_size[1]/pixels_per_meter[1]) - (img_size[0]//2)/pixels_per_meter[0]
from matplotlib.pyplot import ylim
import math
from scipy import interpolate
from scipy.interpolate import interp1d
#%% First function:
# Interpolations with monomials:
x = np.linspace(-1, 1, num = 20, endpoint = True) # If we increase the range, we could see better the behaviour of that function
y = np.exp(1/x)
# First part. Interpolations with monomials:
pol3 = np.polyfit(x, y, 3)
val3 = np.polyval(pol3, x)
pol5 = np.polyfit(x, y, 5)
val5 = np.polyval(pol5, x)
pol10 = np.polyfit(x, y, 10)
val10 = np.polyval(pol10, x)
plt.plot(x, y, label = 'Original function')
plt.plot(x, val3,'-', label = 'Interpolation order 3')
plt.plot(x, val5,'--', label = 'Interpolation order 5')
plt.plot(x, val10,':', label = 'Interpolation order 10')
plt.legend(loc = 'upper left')
plt.xlim(xmin = -1, xmax = 1)
plt.title('Monomial interpolations - Eq. 1', size=15)
plt.ylabel('f(x)', size=10)
@author: zhouning
@file:test_numpy_fit.py
@time:2018/7/11 17:16
@desc:多项式拟合范例：
"""
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(1, 17, 1)
y = np.array([
3.10323, 3.20646, 3.30969, 5.41292, 3.51615, 3.61938, 3.72261, 3.82584,
3.92907, 4.0323, 4.13553, 4.23876, 4.34199, 4.44522, 4.54845, 4.65168
])
z1 = np.polyfit(x, y, 2) # 用2次多项式拟合
p1 = np.poly1d(z1)
print(p1) # 在屏幕上打印拟合多项式
# yvals = p1(x) # 也可以使用yvals=np.polyval(z1,x)
yvals = np.polyval(z1, x) # 也可以使用yvals=np.polyval(z1,x)
print(type(yvals))
plot1 = plt.plot(x, y, '*', label='original values')
plot2 = plt.plot(x, yvals, 'r', label='polyfit values')
plt.xlabel('x axis')
plt.ylabel('y axis')
plt.legend(loc=4) # 指定legend的位置,读者可以自己help它的用法
plt.title('polyfitting')
plt.show()
plt.savefig('p1.png')
def tpoly(q0, qf, t, qd0=0, qdf=0):
"""
Generate scalar polynomial trajectory
:param q0: initial value
:type q0: float
:param qf: final value
:type qf: float
:param t: time
:type t: float or array_like
:param qd0: initial velocity, optional
:type q0: float
:param qdf: final velocity, optional
:type q0: float
:return: trajectory
:rtype: namedtuple
- ``tg = lspb(q0, q1, t)`` is a scalar trajectory (Mx1) that varies smoothly
from ``q0`` to ``qf`` using a quintic polynomial. The initial and final
velocity and acceleration are zero. Time ``t`` can be either:
* an integer scalar, indicating the total number of timesteps
- Velocity is in units of distance per trajectory step, not per
second.
- Acceleration is in units of distance per trajectory step squared,
*not* per second squared.
* an array_like, containing the time steps.
- Results are scaled to units of time.
- ``tg = lspb(q0, q1, t, qd0, qdf)`` as above but specify the initial and
final velocity. The initial and final acceleration are zero.
The return value is a namedtuple (named ``tpoly``) with elements:
- ``x`` the time coordinate as a numpy ndarray, shape=(M,)
- ``y`` the position as a numpy ndarray, shape=(M,)
- ``yd`` the velocity as a numpy ndarray, shape=(M,)
- ``ydd`` the acceleration as a numpy ndarray, shape=(M,)
Notes:
- The time vector T is assumed to be monotonically increasing, and time
scaling is based on the first and last element.
References:
- Robotics, Vision & Control, Chap 3,
P. Corke, Springer 2011.
:seealso: :func:`lspb`, :func:`t1plot`, :func:`jtraj`.
"""
if isinstance(t, int):
t = np.arange(0, t)
istime = False
elif isvector(t):
t = getvector(t)
istime = True
else:
raise TypeError('bad argument for time, must be int or vector')
tf = max(t)
# solve for the polynomial coefficients using least squares
X = [
[0, 0, 0, 0, 0, 1],
[tf ** 5, tf ** 4, tf ** 3, tf ** 2, tf, 1],
[0, 0, 0, 0, 1, 0],
[5 * tf ** 4, 4 * tf ** 3, 3 * tf ** 2, 2 * tf, 1, 0],
[0, 0, 0, 2, 0, 0],
[20 * tf ** 3, 12 * tf ** 2, 6 * tf, 2, 0, 0]
]
coeffs, resid, rank, s = np.linalg.lstsq(X, np.r_[q0, qf, qd0, qdf, 0, 0], rcond=None)
# coefficients of derivatives
coeffs_d = coeffs[0:5] * np.arange(5, 0, -1)
coeffs_dd = coeffs_d[0:4] * np.arange(4, 0, -1)
# evaluate the polynomials
p = np.polyval(coeffs, t)
pd = np.polyval(coeffs_d, t)
pdd = np.polyval(coeffs_dd, t)
return namedtuple('tpoly', 'x y yd ydd istime')(t, p, pd, pdd, istime)
def cdf_to_nc(cdf_filename, atmpres=False):
"""
Load a "raw" .cdf file and generate a processed .nc file
"""
# Load raw .cdf data
ds = xr.open_dataset(cdf_filename)
# definition of PAR is
# PAR = Im * 10 ^ ((x-a0)/a1)
# Where
# Im is the immersion coefficient
# a1 is the scaling factor
# a0 is the voltage offset, typically 0
# x is the voltage
# The manufacturer calculates PAR in units of μmol photons/m2/s1
# from Sea-Bird Scientific, ECO PAR User Manual
# Document No. par170706, 2017-07-06, Version B
# https://www.seabird.com/asset-get.download.jsa?id=54627862518
if "par" in ds.attrs["INST_TYPE"].lower():
ds["PAR_905"] = ds.attrs["Im"] * 10**(
(ds["counts"].mean(dim="sample") - ds.attrs["a0"]) /
ds.attrs["a1"])
ds["PAR_905"].attrs["units"] = "umol m-2 s-1"
ds["PAR_905"].attrs[
"long_name"] = "Photosynthetically active " "radiation"
if "ntu" in ds.attrs["INST_TYPE"].lower():
if "user_ntucal_coeffs" in ds.attrs:
ds["Turb"] = xr.DataArray(
np.polyval(ds.attrs["user_ntucal_coeffs"], ds["counts"]),
dims=["time", "sample"],
).mean(dim="sample")
ds["Turb"].attrs["units"] = "1"
ds["Turb"].attrs["long_name"] = "Turbidity (NTU)"
ds["Turb"].attrs["standard_name"] = "sea_water_turbidity"
ds["Turb_std"] = xr.DataArray(
np.polyval(ds.attrs["user_ntucal_coeffs"], ds["counts"]),
dims=["time", "sample"],
).std(dim="sample")
ds["Turb_std"].attrs["units"] = "1"
ds["Turb_std"].attrs[
"long_name"] = "Turbidity burst standard deviation (NTU)"
ds["Turb_std"].attrs["standard_name"] = "sea_water_turbidity"
ds["Turb_std"].attrs["cell_methods"] = "time: standard_deviation"
ds = ds.drop(["counts", "sample"])
# Clip data to in/out water times or via good_ens
ds = utils.clip_ds(ds)
ds = eco_qaqc(ds)
# assign min/max:
ds = utils.add_min_max(ds)
ds = utils.add_start_stop_time(ds)
ds = utils.add_delta_t(ds)
# add lat/lon coordinates
ds = utils.ds_add_lat_lon(ds)
ds = ds_add_attrs(ds)
ds = utils.create_z(ds)
# add lat/lon coordinates to each variable
for var in ds.variables:
if (var not in ds.coords) and ("time" not in var):
# ds = utils.add_lat_lon(ds, var)
# ds = utils.no_p_add_depth(ds, var)
ds = utils.add_z_if_no_pressure(ds, var)
# cast as float32
# ds = utils.set_var_dtype(ds, var)
# Write to .nc file
print("Writing cleaned/trimmed data to .nc file")
nc_filename = ds.attrs["filename"] + "-a.nc"
ds.to_netcdf(nc_filename,
unlimited_dims=["time"],
encoding={"time": {
"dtype": "i4"
}})
utils.check_compliance(nc_filename)
print("Done writing netCDF file", nc_filename)
# 设置刻度定位器
ax = mp.gca()
ax.xaxis.set_major_locator(md.WeekdayLocator(byweekday=md.MO))
ax.xaxis.set_major_formatter(md.DateFormatter('%Y/%m/%d'))
ax.xaxis.set_minor_locator(md.DayLocator())
# dates = dates.astype(md.datetime.datetime)
mp.gcf().autofmt_xdate()
# 计算差价函数并画出
diff_prices = bhp_closing_prices - vale_closing_prices
mp.plot(dates,
diff_prices,
color='dodgerblue',
label='diff price',
linewidth=1,
linestyle='--')
# 拟合这种数据得到多项式函数方程 画出拟合曲线
x = dates.astype('M8[D]').astype('int32')
y = diff_prices
P = np.polyfit(x, y, 4)
predict_y = np.polyval(P, x)
mp.plot(dates, predict_y, color='orangered', label='predict', linewidth=1)
Q = np.polyder(P)
xs = np.roots(Q)
ys = np.polyval(P, xs)
mp.hlines(ys, dates[0], dates[-1], zorder=0.5, color='green', alpha=0.3)
mp.legend()
mp.show()
def main():
import argparse
import matplotlib.pyplot as plt
import numpy
import os
import scipy.optimize as optimize
from astropy.io import fits as pyfits
# Parsing arguments -------------------------------------------------------
parser = argparse.ArgumentParser(description="Fits an existing phase-map.")
parser.add_argument('filename', type=str, help="Input phase-map name.")
parser.add_argument('-i',
'--interactions',
default=5,
type=int,
help="Number of interactions in the process [5]")
parser.add_argument('-n',
'--npoints',
default=2500,
type=int,
help="Number of points that will be used to fit" +
"the phase-map [50]")
parser.add_argument('-o',
'--output',
type=str,
default=None,
help="Name of the output phase-map file.")
parser.add_argument('-q',
'--quiet',
action='store_true',
help="Run program quietly.")
parser.add_argument(
'-s',
'--show_plots',
action='store_true',
help=
"Show plots (good for checking quality of the observed phase-map and the fitting."
)
args = parser.parse_args()
v = not args.quiet
if v:
print("\n Phase-Map Fitting for BTFI")
print(" by Bruno Quint & Fabricio Ferrari")
print(" version 0.0a - Jan 2014")
print("")
check_dimensions(args.filename, dimensions=2)
# Loading observed map ----------------------------------------------------
if v:
print(" Loading file: %s" % args.filename)
phase_map = pyfits.open(args.filename)[0]
# Check if file was obtained with BTFI instrument
header = phase_map.header
try:
if header['INSTRUME'].upper() not in ['BTFI'] and v:
if v:
print(
" [Warning]: %s file was not obtained with BTFI instrument."
% args.filename)
except KeyError:
warning("'INSTRUME' card was not found in the files' header.")
mode = check_mode(args.filename)
# Fitting Phase-Map for IBTF ----------------------------------------------
if mode == 'ibtf':
if v:
print(" File obtained through an iBTF scan.")
width = phase_map.header['naxis1']
height = phase_map.header['naxis2']
vmin = phase_map.data.mean() - 1.5 * phase_map.data.std()
vmax = phase_map.data.mean() + 1.5 * phase_map.data.std()
plt_config = {
'origin': 'lower',
'cmap': get_colormap(),
'interpolation': 'nearest',
'vmin': vmin,
'vmax': vmax
}
if v:
print(" Phase-map dimensions: [%d, %d]" % (width, height))
print(" Done.")
plt.subplot(131)
plt.imshow(phase_map.data, **plt_config)
plt.xticks([]), plt.yticks([])
plt.xlabel('Observed Map')
# Starting fitting process ------------------------------------------------
npoints = numpy.sqrt(args.npoints).astype(int)
if v:
print("\n Starting phase-map fitting.")
print(" %d x %d points will be used in the process." %
(npoints, npoints))
x = (numpy.linspace(0.1, 0.9, npoints) * width).astype(int)
y = (numpy.linspace(0.1, 0.9, npoints) * height).astype(int)
x, y = numpy.meshgrid(x, y)
x = numpy.ravel(x)
y = numpy.ravel(y)
z = numpy.ravel(phase_map.data[y, x])
fit_func = lambda p, x, y: p[0] + p[1] * x + p[2] * y
err_func = lambda p, x, y, z: z - fit_func(p, x, y)
params = [z.mean(), 0, 0]
# Fitting Plane -----------------------------------------------------------
X = numpy.arange(phase_map.header['naxis1'])
Y = numpy.arange(phase_map.header['naxis2'])
X, Y = numpy.meshgrid(X, Y)
if v: print("")
for i in range(args.interactions):
if v:
print(" Fitting plane - Interaction %d" % (i + 1))
if i == 0: e = z
condition = numpy.where(numpy.abs(e - e.mean()) <= e.std())
xx = x[condition]
yy = y[condition]
zz = z[condition]
params, _ = optimize.leastsq(err_func, params, args=(xx, yy, zz))
Z = fit_func(params, X, Y)
error = Z - phase_map.data
e = numpy.ravel(error[y, x])
if v:
p = params
print(" phi(x,y) = %.2f + %.2fx + %.2fy" % (p[0], p[1], p[2]))
print(" Error abs min: %f" % numpy.abs(e).min())
print(" Error avg: %f" % e.mean())
print(" Error std: %f" % e.std())
print(" Error rms: %f" % numpy.sqrt(((e**2).mean())))
plt.scatter(xx, yy, c=zz, cmap=get_colormap())
plt.xlim(0, width), plt.ylim(0, height)
plt.subplot(132)
plt.imshow(error, **plt_config)
plt.xticks([]), plt.yticks([])
plt.xlabel("Residual")
plt.subplot(133)
plt.imshow(Z, **plt_config)
plt.xticks([]), plt.yticks([])
plt.xlabel("Fitted map")
plt.show()
ref_x = header['PHMREFX']
ref_y = header['PHMREFY']
fname = header['PHMREFF']
fname = os.path.splitext(fname)[0]
pyfits.writeto(fname + '--fit_phmap.fits',
Z - Z[ref_y, ref_x],
header,
clobber=True)
pyfits.writeto(fname + '--res_phmap.fits',
Z - phase_map.data,
header,
clobber=True)
print("")
# Fitting phase-map for a Fabry-Perot Map ---------------------------------
elif mode == 'fp':
npoints = numpy.sqrt(args.npoints).astype(int)
if v:
print(" File obtained through a Fabry-Perot scan.")
print(" Starting phase-map fitting.")
print(" %d x %d points will be used in the process." %
(npoints, npoints))
# Read data
width = header['NAXIS1']
height = header['NAXIS2']
ref_x = header['PHMREFX']
ref_y = header['PHMREFY']
unit = header['PHMUNIT']
sampling = header['PHMSAMP']
FSR = header['PHMFSR']
phmap = phase_map.data
# From coordinates to pixels
try:
ref_x = header['CRPIX1'] + (ref_x -
header['CRVAL1']) / header['CDELT1']
ref_y = header['CRPIX2'] + (ref_y -
header['CRVAL2']) / header['CDELT2']
except KeyError:
warning(" WCS not found. Using phisical coordinates.")
phmap = phmap - phmap[ref_y, ref_x]
x = (numpy.linspace(0.05, 0.95, npoints) * width).astype(int)
y = (numpy.linspace(0.05, 0.95, npoints) * height).astype(int)
X, Y = numpy.meshgrid(x, y)
R = numpy.sqrt((X - ref_x)**2 + (Y - ref_y)**2)
Z = phmap[Y, X]
if args.show_plots:
phmap_figure = plt.figure()
phmap_axes = phmap_figure.add_subplot(111)
phmap_imshow = phmap_axes.imshow(phmap,
origin='lower',
interpolation='nearest',
cmap='coolwarm')
phmap_axes.scatter(ref_x,
ref_y,
c='orange',
s=400,
marker="+",
lw=3)
phmap_axes.scatter(X, Y, c='g', s=1, marker=".", alpha=0.7)
phmap_axes.set_xlabel("X [px]")
phmap_axes.set_ylabel("Y [px]")
phmap_axes.set_xlim(0, width)
phmap_axes.set_ylim(0, height)
phmap_axes.grid()
phmap_figure.colorbar(phmap_imshow)
x = numpy.ravel(X)
y = numpy.ravel(Y)
r = numpy.sqrt((x - ref_x)**2 + (y - ref_y)**2)
z = numpy.ravel(Z)
condition = numpy.where(z > z.min(), True, False) * \
numpy.where(z < z.max(), True, False)
r = r[condition]
z = z[condition]
z = z[numpy.argsort(r)]
r = numpy.sort(r)
# Checking if parabola is up or down.
if v:
print("\n Checking if parabola is up or down.")
dz = numpy.diff(z, 1)
dz_abs = numpy.abs(dz)
dz_sign = numpy.sign(dz)
sign = numpy.median(dz_sign[(dz_sign != 0) * (dz_abs <= sampling)])
if v:
print(" Parabola is %s" % ('up' if sign > 0 else 'down'))
# Tell me the limits to fit the first parabola
where = numpy.argmin(numpy.abs(r[dz_abs >= FSR / 2][0] - r))
# Plot the gradient
if args.show_plots:
plt.figure(figsize=(16, 7))
plt.subplot(2, 2, 3)
plt.plot(r[1:], dz, 'b-')
plt.gca().yaxis.set_label_position("right")
plt.axvline(r[where], color='black', lw=2, ls='--')
plt.axhline(FSR / 2, color='red', ls='--', label="FSR")
plt.axhline(-FSR / 2, color='red', ls='--')
plt.xlabel('Radius [px]')
plt.ylabel('Gradient \n [%s]' % unit)
plt.legend(loc='best')
plt.grid()
# This is the first fit
p = numpy.polyfit(r[:where], z[:where], 2)
rr = numpy.linspace(r[0], r[where], 1000)
zz = numpy.polyval(p, rr)
# Plot the data before correction
if args.show_plots:
plt.subplot(2, 2, 1)
plt.plot(r[:where],
z[:where],
'b.',
alpha=0.25,
label='Not to be fixed')
plt.plot(r[where:],
z[where:],
'r.',
alpha=0.25,
label='Data to be fixed')
plt.plot(rr, zz, 'k-', lw=2)
plt.axvline(r[where], color='black', lw=2, ls='--')
plt.gca().yaxis.set_label_position("right")
plt.xlabel('Radius [px]')
plt.ylabel('Peak displacement \n [%s]' % unit)
plt.legend(loc='best')
plt.grid()
# Displace the FSR
error = numpy.abs(z - numpy.polyval(p, r) + sign * FSR)
# Plot error
if args.show_plots:
plt.subplot(2, 2, 4)
plt.plot(r, error, 'k.', alpha=0.25)
# plt.gca().yaxis.tick_right()
plt.gca().yaxis.set_label_position("right")
plt.xlabel('Radius [px]')
plt.ylabel('Error \n [%s]' % unit)
plt.ylim(ymin=-50, ymax=1.1 * error.max())
plt.grid()
condition = (error > 2 * sampling)
# Plot data after correction
if args.show_plots:
plt.subplot(2, 2, 2)
plt.plot(r[condition],
z[condition],
'b.',
alpha=0.25,
label='Not fixed data')
plt.plot(r[~condition],
z[~condition] + sign * FSR,
'r.',
alpha=0.25,
label='Fixed data')
plt.gca().yaxis.set_label_position("right")
plt.xlabel('Radius [px]')
plt.ylabel('Peak displacement \n [%s]' % unit)
plt.grid()
# This is the second fit
z = numpy.where(error >= 2 * sampling, z, z + sign * FSR)
p = numpy.polyfit(r, z, 2)
if args.show_plots:
rr = numpy.linspace(r[0], r[-1], 1000)
zz = numpy.polyval(p, rr)
plt.plot(rr, zz, 'k-', lw=2, label='Fitted data.')
plt.legend(loc='best')
error = z - numpy.polyval(p, r)
if v:
print(" phi(x,y) = %.2e x^2 + %.2e x + %.2e " %
(p[0], p[1], p[2]))
print(" Error abs min: %f" % numpy.abs(error).min())
print(" Error avg: %f" % error.mean())
print(" Error std: %f" % error.std())
print(" Error rms: %f" % numpy.sqrt(((error**2).mean())))
print(" Sampling in Z: %s" % phase_map.header['phmsamp'])
print(" ")
x = numpy.arange(width)
y = numpy.arange(height)
X, Y = numpy.meshgrid(x, y)
R = numpy.sqrt((X - ref_x)**2 + (Y - ref_y)**2)
Z = numpy.polyval(p, R)
Z = Z - Z[ref_y, ref_x]
fname = header['PHMREFF']
fname = os.path.splitext(fname)[0]
pyfits.writeto(fname + '--fit_phmap.fits', Z, header, clobber=True)
pyfits.writeto(fname + '--res_phmap.fits',
Z - phmap,
header,
clobber=True)
if v:
print(" All done.\n")
if args.show_plots:
plt.show()
else:
if v: print(" [Warning]: File was not obtained from FP or iBTF.")
if v: print(" [Warning]: Don't know what to do. Leaving now.\n")
from sys import exit
exit()
def mark_orders(
im,
min_cluster=None,
min_width=None,
filter_size=None,
noise=None,
opower=4,
border_width=None,
degree_before_merge=2,
regularization=0,
closing_shape=(5, 5),
opening_shape=(2, 2),
plot=False,
plot_title=None,
manual=True,
auto_merge_threshold=0.9,
merge_min_threshold=0.1,
sigma=0,
):
""" Identify and trace orders
Parameters
----------
im : array[nrow, ncol]
order definition image
min_cluster : int, optional
minimum cluster size in pixels (default: 500)
filter_size : int, optional
size of the running filter (default: 120)
noise : float, optional
noise to filter out (default: 8)
opower : int, optional
polynomial degree of the order fit (default: 4)
border_width : int, optional
number of pixels at the bottom and top borders of the image to ignore for order tracing (default: 5)
plot : bool, optional
wether to plot the final order fits (default: False)
manual : bool, optional
wether to manually select clusters to merge (strongly recommended) (default: True)
Returns
-------
orders : array[nord, opower+1]
order tracing coefficients (in numpy order, i.e. largest exponent first)
"""
# Convert to signed integer, to avoid underflow problems
im = np.asanyarray(im)
im = im.astype(int)
if filter_size is None:
col = im[:, im.shape[0] // 2]
col = median_filter(col, 5)
threshold = np.percentile(col, 90)
npeaks = find_peaks(col, height=threshold)[0].size
filter_size = im.shape[0] // (npeaks * 2)
logger.info("Median filter size, estimated: %i", filter_size)
elif filter_size <= 0:
raise ValueError(f"Expected filter size > 0, but got {filter_size}")
if border_width is None:
# find width of orders, based on central column
col = im[:, im.shape[0] // 2]
col = median_filter(col, 5)
idx = np.argmax(col)
width = peak_widths(col, [idx])[0][0]
border_width = int(np.ceil(width))
logger.info("Image border width, estimated: %i", border_width)
elif border_width < 0:
raise ValueError(f"Expected border width > 0, but got {border_width}")
if min_cluster is None:
min_cluster = im.shape[1] // 4
logger.info("Minimum cluster size, estimated: %i", min_cluster)
elif not np.isscalar(min_cluster):
raise TypeError(
f"Expected scalar minimum cluster size, but got {min_cluster}")
if min_width is None:
min_width = 0.25
if min_width == 0:
pass
elif isinstance(min_width, (float, np.floating)):
min_width = int(min_width * im.shape[0])
logger.info("Minimum order width, estimated: %i", min_width)
# im[im < 0] = np.ma.masked
blurred = grey_closing(im, 5)
# blur image along columns, and use the median + blurred + noise as threshold
blurred = gaussian_filter1d(blurred, filter_size, axis=0)
if noise is None:
tmp = np.abs(blurred.flatten())
noise = np.percentile(tmp, 5)
logger.info("Background noise, estimated: %f", noise)
elif not np.isscalar(noise):
raise TypeError(f"Expected scalar noise level, but got {noise}")
mask = im > blurred + noise
# remove borders
if border_width != 0:
mask[:border_width, :] = mask[-border_width:, :] = False
mask[:, :border_width] = mask[:, -border_width:] = False
# remove masked areas with no clusters
mask = np.ma.filled(mask, fill_value=False)
# close gaps inbetween clusters
struct = np.full(closing_shape, 1)
mask = morphology.binary_closing(mask, struct, border_value=1)
# remove small lonely clusters
struct = np.full(opening_shape, 1)
# struct = morphology.generate_binary_structure(2, 1)
mask = morphology.binary_opening(mask, struct)
# label clusters
clusters, _ = label(mask)
# remove small clusters
sizes = np.bincount(clusters.ravel())
mask_sizes = sizes > min_cluster
mask_sizes[
0] = True # This is the background, which we don't need to remove
for i in np.arange(len(sizes))[~mask_sizes]:
clusters[clusters == i] = 0
# # Reorganize x, y, clusters into a more convenient "pythonic" format
# # x, y become dictionaries, with an entry for each order
# # n is just a list of all orders (ignore cluster == 0)
n = np.unique(clusters)
n = n[n != 0]
x = {i: np.where(clusters == c)[0] for i, c in enumerate(n)}
y = {i: np.where(clusters == c)[1] for i, c in enumerate(n)}
def best_fit_degree(x, y):
L1 = np.sum((np.polyval(np.polyfit(y, x, 1), y) - x)**2)
L2 = np.sum((np.polyval(np.polyfit(y, x, 2), y) - x)**2)
# aic1 = 2 + 2 * np.log(L1) + 4 / (x.size - 2)
# aic2 = 4 + 2 * np.log(L2) + 12 / (x.size - 3)
if L1 < L2:
return 1
else:
return 2
if sigma > 0:
degree = {i: best_fit_degree(x[i], y[i]) for i in x.keys()}
bias = {i: np.polyfit(y[i], x[i], deg=degree[i])[-1] for i in x.keys()}
n = list(x.keys())
yt = np.concatenate([y[i] for i in n])
xt = np.concatenate([x[i] - bias[i] for i in n])
coef = np.polyfit(yt, xt, deg=degree_before_merge)
res = np.polyval(coef, yt)
cutoff = sigma * (res - xt).std()
# DEBUG plot
# uy = np.unique(yt)
# mask = np.abs(res - xt) > cutoff
# plt.plot(yt, xt, ".")
# plt.plot(yt[mask], xt[mask], "r.")
# plt.plot(uy, np.polyval(coef, uy))
# plt.show()
#
m = {
i: np.abs(np.polyval(coef, y[i]) - (x[i] - bias[i])) < cutoff
for i in x.keys()
}
k = max(x.keys()) + 1
for i in range(1, k):
new_img = np.zeros(im.shape, dtype=int)
new_img[x[i][~m[i]], y[i][~m[i]]] = 1
clusters, _ = label(new_img)
x[i] = x[i][m[i]]
y[i] = y[i][m[i]]
if len(x[i]) == 0:
del x[i], y[i]
nnew = np.max(clusters)
if nnew != 0:
xidx, yidx = np.indices(im.shape)
for j in range(1, nnew + 1):
xn = xidx[clusters == j]
yn = yidx[clusters == j]
if xn.size >= min_cluster:
x[k] = xn
y[k] = yn
k += 1
# plt.imshow(clusters, origin="lower")
# plt.show()
if plot: # pragma: no cover
title = "Identified clusters"
if plot_title is not None:
title = f"{plot_title}\n{title}"
plt.title(title)
plt.xlabel("x [pixel]")
plt.ylabel("y [pixel]")
clusters = np.ma.zeros(im.shape, dtype=int)
for i in x.keys():
clusters[x[i], y[i]] = i + 1
clusters[clusters == 0] = np.ma.masked
plt.imshow(clusters, origin="lower", cmap="prism")
plt.show()
# Merge clusters, if there are even any possible mergers left
x, y, n = merge_clusters(
im,
x,
y,
n,
manual=manual,
deg=degree_before_merge,
auto_merge_threshold=auto_merge_threshold,
merge_min_threshold=merge_min_threshold,
plot_title=plot_title,
)
if min_width > 0:
sizes = {k: v.max() - v.min() for k, v in y.items()}
mask_sizes = {k: v > min_width for k, v in sizes.items()}
for k, v in mask_sizes.items():
if not v:
del x[k]
del y[k]
n = x.keys()
orders = fit_polynomials_to_clusters(x, y, n, opower)
# sort orders from bottom to top, using relative position
def compare(i, j):
_, xi, i_left, i_right = i
_, xj, j_left, j_right = j
if i_right < j_left or j_right < i_left:
return xi.mean() - xj.mean()
left = max(i_left, j_left)
right = min(i_right, j_right)
return xi[left:right].mean() - xj[left:right].mean()
xp = np.arange(im.shape[1])
keys = [(c, np.polyval(orders[c], xp), y[c].min(), y[c].max())
for c in x.keys()]
keys = sorted(keys, key=cmp_to_key(compare))
key = [k[0] for k in keys]
n = np.arange(len(n), dtype=int)
x = {c: x[key[c]] for c in n}
y = {c: y[key[c]] for c in n}
orders = np.array([orders[key[c]] for c in n])
column_range = np.array([[np.min(y[i]), np.max(y[i]) + 1] for i in n])
if plot: # pragma: no cover
plot_orders(im, x, y, n, orders, column_range, title=plot_title)
return orders, column_range
def AnalyseDetector(data,
bias=[-1],
inputpower=6.0,
gratingloss=-4.0,
figname=None):
'''Analyse the detector measurement result in 'data' and return
-dark current at bias
-light current at bias
-responsivity at bias
Arguments:
-data: the PortLossMeasurement node, read from XML using lxml.objectify,
obtained by running the DetectorMeasurement recipe.
-bias (list): bias voltage(s) (V) at which to evaluate the device parameters
-inputpower (float): optical power at the tip of the input fiber (dBm)
-gratingloss (float): optical loss of the input grating (dB).
-figname (str): name of a file where a plot of the IV measurements will
be saved. Default is None, in which case no plot will be made.
Returns:
-result (DetectorMeasurementResult): object that stores all the
analysis results.
'''
result = DetectorAnalysisResult()
pl = data #.PortLossMeasurement
#fill in the measurement conditions in the result object:
result.Wavelength = float(pl.LightCurrent.attrib['Wavelength'])
result.LaserPower = float(pl.LightCurrent.attrib['Power'])
powerunit = pl.LightCurrent.attrib['PowerUnit']
#if 'dbm' in powerunit.lower():
# #convert to mW
# result.LaserPower = 10**(result.LaserPower/10)
lshift = pl.PositionerInfo.LeftFibre.attrib['Shift']
shiftx = float(lshift[1:-1].split(',')[0])
shifty = float(lshift[1:-1].split(',')[1])
result.FiberShift = (shiftx**2 + shifty**2)**0.5
result.Bias = bias
result.FiberOutput = inputpower
result.GratingLoss = gratingloss
pwratdetect = inputpower + gratingloss
result.PowerAtDetector = 10**(pwratdetect / 10)
datetime = time.strptime(pl.attrib['DateStamp'], "%a %b %d %X %Y")
result.Date = time.strftime("%Y%m%d", datetime)
result.Time = time.strftime("%X", datetime)
#extract the detector properties: dark current, light current,
#responsivity
darkv = pl.DarkCurrent.V.pyval
darkv = np.genfromtxt(StringIO(darkv), delimiter=',')
darki = pl.DarkCurrent.I.pyval
darki = np.genfromtxt(StringIO(darki), delimiter=',')
iunit = pl.DarkCurrent.I.attrib['Unit']
if "symbol='mA'" in iunit:
darki = darki * 0.001
lightv = pl.LightCurrent.V.pyval
lightv = np.genfromtxt(StringIO(lightv), delimiter=',')
lighti = pl.LightCurrent.I.pyval
lighti = np.genfromtxt(StringIO(lighti), delimiter=',')
iunit = pl.LightCurrent.I.attrib['Unit']
if "symbol='mA'" in iunit:
lighti = lighti * 0.001
for b in bias:
#dark current:
P = np.polyfit(darkv, darki, 7)
#result.DarkCurrent.append(np.polyval(P, b))
dark_idx = np.argwhere(darkv == b)[0]
result.DarkCurrent.append(darki[dark_idx[0]])
if (not figname is None):
_, ax = plt.subplots()
ax.plot(darkv, darki, label='dark')
ax.hold(True)
ax.plot(darkv[dark_idx[0]], result.DarkCurrent[-1], '^')
ax.plot(darkv, np.polyval(P, darkv), '.', label='dark_fit')
ax.grid(True)
#light current:
P = np.polyfit(lightv, lighti, 7)
#result.LightCurrent.append(np.polyval(P, b))
light_idx = np.argwhere(lightv == b)[0]
result.LightCurrent.append(lighti[light_idx[0]])
if (not figname is None):
ax.plot(lightv, lighti, label='light')
ax.hold(True)
ax.plot(lightv[light_idx[0]], result.LightCurrent[-1], 's')
ax.plot(lightv, np.polyval(P, lightv), '-.', label='light_fit')
ax.grid(True)
handles, labels = ax.get_legend_handles_labels()
ax.legend(handles, labels, loc='lower right')
plt.savefig(figname, bbox_inches='tight')
#responsivity:
result.Responsivity.append(np.abs(result.LightCurrent[-1] - \
result.DarkCurrent[-1]))
result.Responsivity[-1] *= 1000 / result.PowerAtDetector
return result
def plotDerivative(df,
dropMap,
label,
channel,
low=0,
high=5,
namePath='',
nbpt=2):
choice = ['blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'black']
colors = choice[0:len(label)]
for j, tmp in enumerate(label):
y = []
x = []
d = []
m = 0
R = []
for i, content in enumerate(dropMap[:, 1]):
if content == tmp:
if channel == 'mCherry':
p = df[i]
y = np.array(np.log(p.fluo_2_mean))
x = np.array(p.time / 3600)
if channel == 'GFP':
p = df[i]
y = np.array(np.log(p.fluo_3_mean))
x = np.array(p.time / 3600)
if channel == 'PVD':
p = df[i]
y = np.array(np.log(p.fluo_1_mean))
x = np.array(p.time / 3600)
#dforth=np.gradient(y[0::nbpt],x[0::nbpt])
#dback=np.gradient(y[1::nbpt],x[1::nbpt])
dforth = []
dback = []
for i in range(0,
len(x) - 1,
2): #step two to split back and forth
xF = np.array(x[i + 0:i + nbpt:2])
xB = np.array(x[i + 1:i + nbpt + 1:2])
yF = np.array(y[i + 0:i + nbpt:2])
yB = np.array(y[i + 1:i + nbpt + 1:2])
f = np.polyfit(xF, yF, 1, full=True)
dforth.append(f[0][0])
#print(f)
f = np.polyfit(xB, yB, 1, full=True)
dback.append(f[0][0])
chi_squaredB = np.sum(
(np.polyval(f[0], xB) - yB)**2) / len(xB)
R.append(chi_squaredB)
chi_squaredF = np.sum(
(np.polyval(f[0], xF) - yF)**2) / len(xF)
R.append(chi_squaredF)
plt.scatter(x[0:-1:2], np.abs(dforth), color='blue')
plt.scatter(x[1::2], np.abs(dback), color='red')
plt.plot(x[0:-1:2], np.abs(dforth), color='blue')
plt.plot(x[1::2], np.abs(dback), color='red')
if m < np.max(dback):
m = np.max(dback)
if m < np.max(dforth):
m = np.max(dforth)
plt.plot(x, np.ones(len(x)) * m * .5)
fig1 = plt.gcf()
plt.ylim([0, 2])
plt.xlim([0, 40])
plt.title(' '.join(label) + ' ' + ' '.join(choice[0:len(label)]) +
"\nchannel=" + str(channel) + "\nnbpts=" + str(nbpt))
plt.xlabel('time (h)')
plt.ylabel('derive fluo (ua)')
plt.show()
if namePath != '':
fig1.savefig(namePath)
hist, bins = np.histogram(R, bins=50)
width = 0.7 * (bins[1] - bins[0])
center = (bins[:-1] + bins[1:]) / 2
plt.bar(center, hist, align='center', width=width)
# plt.xlim([0, 1])
plt.ylim([0, 10])
plt.show()
def curved_road_2(self, file, imgFromRealSense=False):
"""
Algorithm to calculate where a curved road is in the image.
:param file:
:param imgFromRealSense:
:return:
"""
# load the image
self.load_image(file, imgFromRealSense=imgFromRealSense)
cv2.imshow('Full image', self.img)
# Take bottom half of image
#imgh = self.horizontal_segment_image(self.img, 2, 1) # first index contains y values, second index contains x values
imgh = self.img[130:self.img.shape[0], 0:(self.img.shape[1])]
cv2.imshow('Bottom half', imgh)
# Detect yellow/white
imgyh = cd.detect_hue(imgh, "yellow", val_thresh=50, sat_thresh=130)
# Edge detection
imgyhe = cv2.Canny(imgyh,
rdp.EDGE_LOW_THRESHOLD_DEFAULT,
rdp.EDGE_HIGH_THRESHOLD_DEFAULT,
edges=rdp.EDGE_TYPE,
apertureSize=rdp.EDGE_APERTURE_DEFAULT,
L2gradient=rdp.EDGE_L2GRADIENT)
imgyhe = cv2.blur(imgyhe, (3, 3))
cv2.imshow('edges', imgyhe)
#imgyhec = cv2.cvtColor(imgyhe, cv2.COLOR_GRAY2BGR)
imgyhec = np.zeros((imgyhe.shape[0], imgyhe.shape[1], 3), np.uint8)
# Hough Lines P
lines = cv2.HoughLinesP(imgyhe,
10,
np.pi / 180,
200,
lines=None,
minLineLength=3)
#print(lines)
x_pts = []
y_pts = []
rt_x_pts = []
rt_y_pts = []
lf_x_pts = []
lf_y_pts = []
for seg in lines:
x_pts.append(seg[0][0])
x_pts.append(seg[0][2])
y_pts.append(seg[0][1])
y_pts.append(seg[0][3])
if seg[0][0] > 630:
rt_x_pts.append(seg[0][0])
rt_x_pts.append(seg[0][2])
rt_y_pts.append(seg[0][1])
rt_y_pts.append(seg[0][3])
cv2.line(imgyhec, (seg[0][0], seg[0][1]),
(seg[0][2], seg[0][3]), (0, 255, 255))
elif (seg[0][0] > 460) & (seg[0][1] > 100):
lf_x_pts.append(seg[0][0])
lf_x_pts.append(seg[0][2])
lf_y_pts.append(seg[0][1])
lf_y_pts.append(seg[0][3])
cv2.line(imgyhec, (seg[0][0], seg[0][1]),
(seg[0][2], seg[0][3]), (255, 255, 0))
cv2.imshow('segments', imgyhec)
curve = np.polyfit(rt_y_pts, rt_x_pts, 2)
lspace = np.linspace(0, 300, 100)
draw_y = lspace
draw_x = np.polyval(curve, draw_y)
right_points = (np.asarray([draw_x, draw_y]).T).astype(np.int32)
right_points_img = (np.asarray([draw_x,
draw_y + 130]).T).astype(np.int32)
cv2.polylines(imgyhec, [right_points],
False, (0, 150, 225),
thickness=3)
cv2.polylines(self.imglanes, [right_points_img],
False, (255, 0, 225),
thickness=3)
curve = np.polyfit(lf_y_pts, lf_x_pts, 3)
lspace = np.linspace(0, 300, 100)
draw_y = lspace
draw_x = np.polyval(curve, draw_y)
left_points = (np.asarray([draw_x, draw_y]).T).astype(np.int32)
left_points_img = (np.asarray([draw_x,
draw_y + 130]).T).astype(np.int32)
cv2.polylines(imgyhec, [left_points],
False, (255, 0, 225),
thickness=3)
cv2.polylines(self.imglanes, [left_points_img],
False, (255, 0, 225),
thickness=3)
avg_x_pts = []
avg_y_pts = []
for i in range(0, len(right_points)):
a = left_points[i]
b = right_points[i]
avg_x_pts.append((a[0] + b[0]) / 2)
avg_y_pts.append((a[1] + b[1]) / 2)
curve = np.polyfit(avg_y_pts, avg_x_pts, 4)
lspace = np.linspace(0, 300, 100)
draw_y = lspace
draw_x = np.polyval(curve, draw_y)
avg_points = (np.asarray([draw_x, draw_y]).T).astype(np.int32)
avg_points_img = (np.asarray([draw_x,
draw_y + 130]).T).astype(np.int32)
cv2.polylines(imgyhec, [avg_points], False, (255, 0, 225), thickness=3)
cv2.polylines(self.imglanes, [avg_points_img],
False, (127, 255, 127),
thickness=3)
cv2.imshow('curve', imgyhec)
cv2.imshow('Final Result', self.imglanes)
# save the image
cv2.imwrite('curved_demo.jpg', self.imglanes)
N=30,
plot=plot)
print params, params_err
#maximum absolute magnitude
Mst[i][j] = params[1]
Mst_err[i][j] = params_err[1]
print st[i], st_err[i]
print Mst[i][0], Mst_err[i][0]
poly = []
disp = []
for i in range(len(band)):
#fit polynomial to phillips relation, and plot
print "Fitting phillips relation with polynomial."
poly.append(np.polyfit(SNsBV[i], SNM[i], npoly))
fitvals = np.polyval(poly[i], SNsBV[i])
plt.errorbar(SNsBV[i],
SNM[i],
xerr=SNsBV_err[i],
yerr=SNM_err[i],
fmt='r+')
plt.scatter(SNsBV[i], fitvals)
disp.append(np.std(SNM[i] - fitvals))
print disp[i]
plt.ylim(-16, -20)
plt.xlim(1.4, 0.2)
plt.show()
#remove some phillips relation outliers, and plot again
print "Kick out ouliers (>Nsig*dispersion from fit) and fit again."
sBVcur = SNsBV[i][np.absolute(SNM[i] - fitvals) < Nsig * disp[i]]
def plotDerivativeSeparate(df,
dropMap,
label,
channel,
low=0,
high=5,
namePath='',
nbpt=2):
choice = ['blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'black']
colors = choice[0:len(label)]
for j, tmp in enumerate(label):
y = []
x = []
d = []
m = 0
for i, content in enumerate(dropMap[:, 1]):
if content == tmp:
if channel == 'mCherry':
p = df[i]
y = np.array(np.log(p.fluo_2_mean))
x = np.array(p.time / 3600)
if channel == 'GFP':
p = df[i]
y = np.array(np.log(p.fluo_3_mean))
x = np.array(p.time / 3600)
if channel == 'PVD':
p = df[i]
y = np.array(np.log(p.fluo_1_mean))
x = np.array(p.time / 3600)
#dforth=np.gradient(y[0::nbpt],x[0::nbpt])
#dback=np.gradient(y[1::nbpt],x[1::nbpt])
dforth = []
dback = []
xForth = []
xBack = []
xBF = []
dBF = []
RB = []
RF = []
fig, ax1 = plt.subplots() #s(1,3,sharex=True)
a = np.arange(20)
for i in range(0,
len(x) - 1,
2): #step two to split back and forth
xF = np.array(x[i + 0:i + nbpt:2])
xB = np.array(x[i + 1:i + nbpt + 1:2])
yF = np.array(y[i + 0:i + nbpt:2])
yB = np.array(y[i + 1:i + nbpt + 1:2])
f = np.polyfit(xF, yF, 1, full=True)
dforth.append(f[0][0])
xForth.append(np.mean(xF))
thplot = 0
if xB[0] > thplot and xB[
0] < thplot + 20: #plot in the exp phase
ax1.plot(x, func(f[0], x))
plt.ylim(-6, 2)
chi_squaredF = np.sum(
(np.polyval(f[0], xF) - yF)**2) / len(xF)
RF.append(chi_squaredF)
f = np.polyfit(xB, yB, 1, full=True)
dback.append(f[0][0])
xBack.append(np.mean(xB))
if xB[0] > thplot and xB[
0] < thplot + 20: #plot in the exp phase
ax1.plot(x, func(f[0], x))
plt.ylim(-6, 2)
chi_squaredB = np.sum(
(np.polyval(f[0], xB) - yB)**2) / len(xB)
RB.append(chi_squaredB)
#ax1.scatter(x[0::2],y[0::2],color='blue')#,marker='o', linestyle='-',color='blue')
#ax1.scatter(x[1::2],y[1::2],color='red')#,marker='o', linestyle='-',color='red')
#ax1.set_ylim(-6, 2)
#a=np.arange(20)
#ax1.set_title(str(a[:nbpt:2])+' fit')
#ax1[0].set(adjustable='box-forced', aspect='equal')
#plt.show()
#fig, ax1 = plt.subplots()
ax1.scatter(
x[0::2], y[0::2],
color='blue') #,marker='o', linestyle='-',color='blue')
ax1.scatter(
x[1::2], y[1::2],
color='red') #,marker='o', linestyle='-',color='red')
ax1.set_ylim([-6, 2])
ax2 = ax1.twinx()
xBF = xForth + xBack
xBF[::2] = xBack
xBF[1::2] = xForth
dBF = dforth + dback
dBF[::2] = dback
dBF[1::2] = dforth
ax2.plot(xBF, dBF, color='green', marker='*', linestyle='-')
ax2.set_ylim([0, 1])
plt.show()
if m < np.max(dback):
m = np.max(dback)
if m < np.max(dforth):
m = np.max(dforth)
def residuez(b, a, tol=1e-3, rtype='avg'):
"""Compute partial-fraction expansion of b(z) / a(z).
If ``M = len(b)`` and ``N = len(a)``::
b(z) b[0] + b[1] z**(-1) + ... + b[M-1] z**(-M+1)
H(z) = ------ = ----------------------------------------------
a(z) a[0] + a[1] z**(-1) + ... + a[N-1] z**(-N+1)
r[0] r[-1]
= --------------- + ... + ---------------- + k[0] + k[1]z**(-1) ...
(1-p[0]z**(-1)) (1-p[-1]z**(-1))
If there are any repeated roots (closer than tol), then the partial
fraction expansion has terms like::
r[i] r[i+1] r[i+n-1]
-------------- + ------------------ + ... + ------------------
(1-p[i]z**(-1)) (1-p[i]z**(-1))**2 (1-p[i]z**(-1))**n
See also
--------
invresz, poly, polyval, unique_roots
"""
b, a = map(asarray, (b, a))
gain = a[0]
brev, arev = b[::-1], a[::-1]
krev, brev = polydiv(brev, arev)
if krev == []:
k = []
else:
k = krev[::-1]
b = brev[::-1]
p = roots(a)
r = p * 0.0
pout, mult = unique_roots(p, tol=tol, rtype=rtype)
p = []
for n in range(len(pout)):
p.extend([pout[n]] * mult[n])
p = asarray(p)
# Compute the residue from the general formula (for discrete-time)
# the polynomial is in z**(-1) and the multiplication is by terms
# like this (1-p[i] z**(-1))**mult[i]. After differentiation,
# we must divide by (-p[i])**(m-k) as well as (m-k)!
indx = 0
for n in range(len(pout)):
bn = brev.copy()
pn = []
for l in range(len(pout)):
if l != n:
pn.extend([pout[l]] * mult[l])
an = atleast_1d(poly(pn))[::-1]
# bn(z) / an(z) is (1-po[n] z**(-1))**Nn * b(z) / a(z) where Nn is
# multiplicity of pole at po[n] and b(z) and a(z) are polynomials.
sig = mult[n]
for m in range(sig, 0, -1):
if sig > m:
# compute next derivative of bn(s) / an(s)
term1 = polymul(polyder(bn, 1), an)
term2 = polymul(bn, polyder(an, 1))
bn = polysub(term1, term2)
an = polymul(an, an)
r[indx + m -
1] = (polyval(bn, 1.0 / pout[n]) / polyval(an, 1.0 / pout[n]) /
factorial(sig - m) / (-pout[n])**(sig - m))
indx += sig
return r / gain, p, k
def BSM_hedge_run(p=0):
''' Implements delta hedging for a single path. '''
np.random.seed(50000)
#
# Initial Delta
#
ds = 0.01
V_1, S, ex, rg, h, dt = BSM_lsm_put_value(S0 + ds, M, I)
V_2 = BSM_lsm_put_value(S0, M, I)[0]
del_0 = (V_1 - V_2) / ds
#
# Dynamic Hedging
#delt = np.zeros(M + 1, dtype=np.float) # vector for deltas
print("\nAPPROXIMATION OF FIRST ORDER ")
print("-----------------------------")
print(" %7s | %7s | %7s " % ('step', 'S_t', 'Delta'))
for t in xrange(1, M, 1):
if ex[t, p] == 0: # if option is alive
St = S[t, p] # relevant index level
diff = (np.polyval(rg[t], St + ds) - np.polyval(rg[t], St))
# numerator of difference quotient
delt[t] = diff / ds # delta as difference quotient
print(" %7d | %7.2f | %7.2f" % (t, St, delt[t]))
if (S[t, p] - S[t - 1, p]) * (delt[t] - delt[t - 1]) < 0:
print(" wrong")
else:
break
delt[0] = del_0
print("\nDYNAMIC HEDGING OF AMERICAN PUT (BSM)")
print("---------------------------------------")
po = np.zeros(t, dtype=np.float) # vector for portfolio values
vt = np.zeros(t, dtype=np.float) # vector for option values
vt[0] = V_1
po[0] = V_1
bo = V_1 - delt[0] * S0 # bond position value
print("Initial Hedge")
print("Stocks %8.3f" % delt[0])
print("Bonds %8.3f" % bo)
print("Cost %8.3f" % (delt[0] * S0 + bo))
print("\nRegular Rehedges ")
print(68 * "-")
print("step|" + 7 * " %7s|" %
('S_t', 'Port', 'Put', 'Diff', 'Stock', 'Bond', 'Cost'))
for j in range(1, t, 1):
vt[j] = BSM_lsm_put_value(S[j, p], M - j, I)[0]
po[j] = delt[j - 1] * S[j, p] + bo * math.exp(r * dt)
bo = po[j] - delt[j] * S[j, p] # bond position value
print("%4d|" % j + 7 * " %7.3f|" %
(S[j, p], po[j], vt[j],
(po[j] - vt[j]), delt[j], bo, delt[j] * S[j, p] + bo))
errs = po - vt # hedge errors
print("MSE %7.3f" % (np.sum(errs**2) / len(errs)))
print("Average Error %7.3f" % (np.sum(errs) / len(errs)))
print("Total P&L %7.3f" % np.sum(errs))
return S[:, p], po, vt, errs, t
def zmodel(u, zmax, zmax_pfit):
return zmax + np.polyval(zmax_pfit, zmax) * u**3
def residue(b, a, tol=1e-3, rtype='avg'):
"""
Compute partial-fraction expansion of b(s) / a(s).
If ``M = len(b)`` and ``N = len(a)``, then the partial-fraction
expansion H(s) is defined as::
b(s) b[0] s**(M-1) + b[1] s**(M-2) + ... + b[M-1]
H(s) = ------ = ----------------------------------------------
a(s) a[0] s**(N-1) + a[1] s**(N-2) + ... + a[N-1]
r[0] r[1] r[-1]
= -------- + -------- + ... + --------- + k(s)
(s-p[0]) (s-p[1]) (s-p[-1])
If there are any repeated roots (closer together than `tol`), then H(s)
has terms like::
r[i] r[i+1] r[i+n-1]
-------- + ----------- + ... + -----------
(s-p[i]) (s-p[i])**2 (s-p[i])**n
Returns
-------
r : ndarray
Residues.
p : ndarray
Poles.
k : ndarray
Coefficients of the direct polynomial term.
See Also
--------
invres, numpy.poly, unique_roots
"""
b, a = map(asarray, (b, a))
rscale = a[0]
k, b = polydiv(b, a)
p = roots(a)
r = p * 0.0
pout, mult = unique_roots(p, tol=tol, rtype=rtype)
p = []
for n in range(len(pout)):
p.extend([pout[n]] * mult[n])
p = asarray(p)
# Compute the residue from the general formula
indx = 0
for n in range(len(pout)):
bn = b.copy()
pn = []
for l in range(len(pout)):
if l != n:
pn.extend([pout[l]] * mult[l])
an = atleast_1d(poly(pn))
# bn(s) / an(s) is (s-po[n])**Nn * b(s) / a(s) where Nn is
# multiplicity of pole at po[n]
sig = mult[n]
for m in range(sig, 0, -1):
if sig > m:
# compute next derivative of bn(s) / an(s)
term1 = polymul(polyder(bn, 1), an)
term2 = polymul(bn, polyder(an, 1))
bn = polysub(term1, term2)
an = polymul(an, an)
r[indx + m - 1] = polyval(bn, pout[n]) / polyval(an, pout[n]) \
/ factorial(sig - m)
indx += sig
return r / rscale, p, k
def _interpolatedYield(self, t):
yld = np.polyval(self._coeffs, t)
return yld
import numpy #python3 import numpy as np A = np.array(input().split(), float) B = float(input()) print(numpy.polyval(A,B))
elif 'q1' in file:
res.q1 = r
#end if
#end for
if len(res)==2:
q0 = res.q0
q1 = res.q1
ts = q0.timesteps
ip = q1.energies-q0.energies
iperr = sqrt(q1.errs**2+q0.errs**2)
tfit = linspace(0,ts.max(),200)
q0fit = polyval(polyfit(ts,q0.energies,1),tfit)
q1fit = polyval(polyfit(ts,q1.energies,1),tfit)
ipfit = polyval(polyfit(ts,ip,1),tfit)
print()
print()
print('Total energy (q=0, eV)')
for i in range(len(ts)):
print(' {0:<6.4f} {1:<6.4f} +/- {2:<6.4f}'.format(ts[i],q0.energies[i],q0.errs[i]))
#end for
print('----------------------------------')
print(' {0:<6.4f} {1:<6.4f}'.format(0.00,q0fit[0]))
print()
print()
def main():
global Icq1List
global Icq2List
global PAcurrentList
# 配置线损
lossName = PM.query("CONFigure:BASE:FDCorrection:CTABle:CATalog?")
time.sleep(1)
if lossName.find("CMW_loss") != -1:
PM.write("CONFigure:BASE:FDCorrection:CTABle:DELete 'CMW_loss'")
PM.write(
"CONFigure:BASE:FDCorrection:CTABle:CREate 'CMW_loss', 1920000000, 0.8, 1980000000, 0.8, \
2110000000, 0.8, 2170000000, 0.8, 1850000000, 0.8 1910000000, 0.8, 1930000000, 0.8, 1990000000, 0.8,\
824000000, 0.5, 849000000, 0.5, 869000000, 0.5, 894000000, 0.5, 925000000, 0.5, 960000000, 0.5, \
880000000, 0.5, 915000000, 0.5, 2350000000, 0.9, 2535000000, 0.9, 2593000000, 0.9"
)
PM.write("CONFigure:FDCorrection:ACTivate RF1C, 'CMW_loss', RXTX, RF1"
) #配置RF1 Common口的Tx Rx方向损耗
PM.write("CONFigure:FDCorrection:ACTivate RF1O, 'CMW_loss', TX, RF1"
) #配置RF1 OUT口的Tx方向损耗
if PAcurrentGenerateMode == 0:
Icq1 = int(PAcurrentInitial / 256)
Icq2 = int(PAcurrentInitial - Icq1 * 256)
Icq1List = []
Icq2List = []
for ii in range(-LeftExtendPeriodIcq1, RightExtendPeriodIcq1 + 1):
Temp_Icq1 = list(
range(Icq1 + ii * period - ScanRangeIcq1,
Icq1 + ii * period + ScanRangeIcq1 + 1))
Icq1List.extend(Temp_Icq1)
for ii in range(-LeftExtendPeriodIcq2, RightExtendPeriodIcq2 + 1):
Temp_Icq2 = list(
range(Icq2 + ii * period - ScanRangeIcq2,
Icq2 + ii * period + ScanRangeIcq2 + 1))
Icq2List.extend(Temp_Icq2)
if PAcurrentGenerateMode < 2:
PAcurrentList = zeros(len(Icq1List) * len(Icq2List))
for ii in range(len(Icq1List)):
for jj in range(len(Icq2List)):
PAcurrentList[ii + jj * len(Icq1List)] = (Icq1List[ii] * 256 +
Icq2List[jj])
PAcurrentList = list(map(int, PAcurrentList))
print("Icq1List is %s" % Icq1List)
print("Icq2List is %s" % Icq2List)
if PAcurrentListExtendFlag == 1:
PAcurrentList.extend(PAcurrentListExtend)
print("PAcurrentList length is %d" % (len(PAcurrentList)))
print("PAcurrentList is %s" % PAcurrentList)
if ModeChosen in [0, 1]:
ChannelList = channelLteList(bandChosen, LteBW, ScanType)
elif ModeChosen == 2:
ChannelList = channel3GList(bandChosen, ScanType)
if ReadCurrentFlag == 0:
print("expected test time is %3.1f minutes" % float(
len(PAcurrentList) * len(RGIlist) * len(ChannelList) * 16 / 60))
else:
print("Reading current needed, expected test time is %3.1f minutes" %
float(len(PAcurrentList) * len(RGIlist) * len(ChannelList)))
######################### 获取各个控件的位置 ##########################################
######################### 测试过程中请不要操作鼠标和键盘 ###############################
mouse = PyMouse()
key = PyKeyboard()
input("Move mouse to 'Tear Down' then press Enter")
(IsTearDownX, IsTearDownY) = mouse.position() #获取当前坐标的位置
print(IsTearDownX, IsTearDownY)
input("Move mouse to 'Tx Channel' then press Enter")
(TxChannelX, TxChannelY) = mouse.position() #获取当前坐标的位置
print(TxChannelX, TxChannelY)
input("Move mouse to 'Set Radio Config' then press Enter")
(SetRadioConfigX, SetRadioConfigY) = mouse.position() #获取当前坐标的位置
print(SetRadioConfigX, SetRadioConfigY)
input("Move mouse to 'RGI' then press Enter")
(RGIx, RGIy) = mouse.position() #获取当前坐标的位置
print(RGIx, RGIy)
input("Move mouse to 'PA current' then press Enter")
(PAcurrentX, PAcurrentY) = mouse.position() #获取当前坐标的位置
print(PAcurrentX, PAcurrentY)
input("Move mouse to 'Tx Override' then press Enter")
(TxOverrideX, TxOverrideY) = mouse.position() #获取当前坐标的位置
print(TxOverrideX, TxOverrideY)
######################### 获取各个控件的位置 ##########################################
######################### 测试过程中请不要操作鼠标和键盘 ###############################
TimeStart = time.clock()
print("test start. Please check instrument parameters")
interpolateTemp = numpy.zeros([len(RGIlist), 4]) #用来做拟合/插值，便于比较
for ii in range(len(bandChosen)):
if ModeChosen == 0:
PMwrite(PM, "CONFigure:LTE:MEAS:DMODe FDD")
elif ModeChosen == 1:
PMwrite(PM, "CONFigure:LTE:MEAS:DMODe TDD")
if ModeChosen in [0, 1]:
PMwrite(PM, "ROUTe:LTE:MEAS:SCENario:SALone RF1C, RX1")
PMwrite(PM, "CONFigure:LTE:MEAS:BAND %s" % bandChosen[ii])
PMwrite(
PM, "CONFigure:LTE:MEAS:RFSettings:PCC:FREQuency %dCH" %
ChannelList[ii][0])
PMwrite(PM, "CONFigure:LTE:MEAS:MEValuation:REPetition SINGleshot")
PMwrite(PM, "CONFigure:LTE:MEAS:MEValuation:MSUBframes 0, 10, 2")
PMwrite(PM, "CONFigure:LTE:MEAS:PCC:CBANdwidth %s" % LteBW)
PMwrite(
PM,
"TRIGger:LTE:MEAS:MEValuation:SOURce 'Free Run (Fast Sync)'")
PMwrite(PM, "CONFigure:LTE:MEAS:RFSettings:ENPMode MANual")
PMwrite(PM, "CONFigure:LTE:MEAS:RFSettings:ENPower 24")
PMwrite(PM, "CONFigure:LTE:MEAS:RFSettings:UMARgin 12")
PMwrite(PM, "CONFigure:LTE:MEAS:MEValuation:MOEXception ON")
elif ModeChosen == 2:
PMwrite(PM, "ROUTe:WCDMa:MEAS:SCENario:SALone RF1C, RX1")
PMwrite(PM, "CONFigure:WCDMa:MEAS:BAND %s" % bandChosen[ii])
PMwrite(
PM, "CONFigure:WCDMa:MEAS:RFSettings:FREQuency %d CH" %
ChannelList[ii][0])
PMwrite(PM,
"CONFigure:WCDMa:MEAS:MEValuation:REPetition SINGleshot")
PMwrite(PM,
"CONFigure:WCDMa:MEAS:MEValuation:SCOunt:MODulation 10")
PMwrite(PM, "CONFigure:WCDMa:MEAS:MEValuation:SCOunt:SPECtrum 10")
PMwrite(PM, "CONFigure:WCDMa:MEAS:MEValuation:MOEXception ON")
PMwrite(
PM,
"TRIGger:WCDMa:MEAS:MEValuation:SOURce 'Free Run (Fast Sync)'")
PMwrite(PM, "CONFigure:WCDMA:MEAS:RFSettings:ENPower 24")
PMwrite(PM, "CONFigure:WCDMA:MEAS:RFSettings:UMARgin 12")
os.system("pause")
time.sleep(1)
for jj in range(len(ChannelList[ii])):
mouse.click(IsTearDownX, IsTearDownY, 1)
mouse.click(SetRadioConfigX, SetRadioConfigY, 1)
time.sleep(3)
mouse.click(IsTearDownX, IsTearDownY, 1)
mouse.click(TxChannelX, TxChannelY, 1, 2)
key.type_string(str(ChannelList[ii][jj]))
mouse.click(SetRadioConfigX, SetRadioConfigY, 1)
time.sleep(0.2)
if ModeChosen in [0, 1]:
PMwrite(
PM, "CONFigure:LTE:MEAS:RFSettings:PCC:FREQuency %dCH" %
ChannelList[ii][jj])
elif ModeChosen == 2:
PMwrite(
PM, "CONFigure:WCDMa:MEAS:RFSettings:FREQuency %d CH" %
ChannelList[ii][jj])
time.sleep(1)
for kk in range(len(PAcurrentList)):
mouse.click(PAcurrentX, PAcurrentY, 1, 2)
key.type_string(str(PAcurrentList[kk]))
time.sleep(0.2)
Icqq1 = numpy.floor(PAcurrentList[kk] / 256)
Icqq2 = PAcurrentList[kk] - Icqq1 * 256
TestFlag = 1
for ll in range(len(RGIlist)):
mouse.click(RGIx, RGIy, 1, 2)
key.type_string(str(RGIlist[ll]))
time.sleep(0.1)
mouse.click(TxOverrideX, TxOverrideY, 1)
time.sleep(0.1)
try:
if ModeChosen in [0, 1]:
PM.write("ABORt:LTE:MEAS:MEValuation")
PM.write("INIT:LTE:MEAS:MEValuation")
time.sleep(0.7)
LteAclr = PMquery(
PM, "FETCh:LTE:MEAS:MEValuation:ACLR:AVERage?"
) #读取UE发射功率
LteAclrList = list(map(float, LteAclr.split(',')))
UEPwr = LteAclrList[4]
ChPwr = LteAclrList[4]
AdjCLRn = LteAclrList[3]
AdjCLRp = LteAclrList[5]
elif ModeChosen == 2:
PMwrite(PM, "ABORt:WCDMa:MEAS:MEValuation")
WAclrList = PMqueryWithDelay(
PM,
"READ:WCDMa:MEAS:MEValuation:SPECtrum:AVERage?"
).split(',')
UEPwr = float(WAclrList[15])
ChPwr = float(WAclrList[1])
AdjCLRn = ChPwr - float(WAclrList[3])
AdjCLRp = ChPwr - float(WAclrList[4])
except Exception:
print("TxPwr underdriven or overdriven, ignored")
TestFlag = -1
break
if (AdjCLRn < 30 and ChPwr < 23):
print("ACLR too bad, ignored")
TestFlag = 0
break
if TestFlag == 1:
interpolateTemp[ll][0] = AdjCLRn
interpolateTemp[ll][1] = ChPwr
interpolateTemp[ll][2] = AdjCLRp
if ReadCurrentFlag == 1:
if ReadCurrentWaitTime == "Manual":
os.system("pause")
else:
time.sleep(int(ReadCurrentWaitTime))
if ModeChosen == 1:
CurrentLength = 40
else:
CurrentLength = 15
Current = numpy.zeros(CurrentLength)
for k in range(CurrentLength):
Current[k] = float(
PMquery(PM_DCsupply, "MEASure:CURRent?"))
print(Current[k])
time.sleep(0.1 + numpy.random.rand() * 0.3)
if ModeChosen == 1:
temp_current = sorted(Current)
interpolateTemp[ll][3] = average(
temp_current[2:(CurrentLength - 2)])
else:
interpolateTemp[ll][3] = average(Current)
else:
interpolateTemp[ll][3] = 0.001
print("%-4s %d %s %s %3d %3d %3.2f %3.2f %3.2f %1.3f" %(bandChosen[ii], ChannelList[ii][jj],\
RGIlist[ll],PAcurrentList[kk],Icqq1, Icqq2, AdjCLRn,ChPwr,AdjCLRp,interpolateTemp[ll][3]))
elif TestFlag == -1:
print("%-4s %d %s %s %3d %3d underdriven or overdriven, ignored" %(bandChosen[ii], ChannelList[ii][jj],\
RGIlist[ll],PAcurrentList[kk],Icqq1, Icqq2))
else:
print("%-4s %d %s %s %3d %3d ACLR too bad, ignored" %(bandChosen[ii], ChannelList[ii][jj],\
RGIlist[ll],PAcurrentList[kk],Icqq1, Icqq2))
if TestFlag == 1:
Tmp1 = numpy.polyfit(interpolateTemp[:, 1],
interpolateTemp[:, 0],
len(RGIlist) - 1)
Tmp2 = numpy.polyfit(interpolateTemp[:, 1],
interpolateTemp[:, 2],
len(RGIlist) - 1)
Tmp3 = numpy.polyfit(interpolateTemp[:, 1],
interpolateTemp[:, 3],
len(RGIlist) - 1)
interpolateAclrLeft = numpy.polyval(Tmp1, IpNP)
interpolateAclrRight = numpy.polyval(Tmp2, IpNP)
interpolateCurrent = numpy.polyval(Tmp3, IpNP)
print("%-4s %d -- %s %3d %3d %3.2f %3.1f %3.2f %1.3f" %(bandChosen[ii], ChannelList[ii][jj],\
PAcurrentList[kk],Icqq1, Icqq2, interpolateAclrLeft,IpNP,interpolateAclrRight, interpolateCurrent))
LogfileWrite(LogFile, "%-4s %d -- %s %3d %3d %3.2f %3.1f %3.2f %1.3f\n" %(bandChosen[ii], ChannelList[ii][jj],\
PAcurrentList[kk],Icqq1, Icqq2, interpolateAclrLeft,IpNP,interpolateAclrRight, interpolateCurrent))
elif TestFlag == -1:
print("%-4s %d -- %s %3d %3d -- %3.1f --" %(bandChosen[ii], ChannelList[ii][jj],\
PAcurrentList[kk],Icqq1, Icqq2, IpNP))
LogfileWrite(LogFile, "%-4s %d -- %s %3d %3d -- %3.1f --\n" %(bandChosen[ii], ChannelList[ii][jj],\
PAcurrentList[kk],Icqq1, Icqq2, IpNP))
else:
print("%-4s %d -- %s %3d %3d bad %3.1f bad" %(bandChosen[ii], ChannelList[ii][jj],\
PAcurrentList[kk],Icqq1, Icqq2, IpNP))
LogfileWrite(LogFile, "%-4s %d -- %s %3d %3d bad %3.1f bad\n" %(bandChosen[ii], ChannelList[ii][jj],\
PAcurrentList[kk],Icqq1, Icqq2, IpNP))
############################## All test end ##########################
TimeEnd = time.clock()
print("The total test time is %.1f minutes" % ((TimeEnd - TimeStart) / 60))
endtime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))
print("Test finished at %s" % endtime)
LogfileWrite(LogFile, "Test finished at %s\n\n" % endtime)
