def main(data_files1, data_files2,
err, B=0.5003991, l=2e-2, w=1e-2,
outfile=None):
mu_H = lambda V_5, V_1: V_5 * l / ( V_1 * B * w)
mu_He = lambda V_5, V_1, V_5e, V_1e: pylab.sqrt(\
( (l / ( V_1 * B * w)) * V_5e )**2 +\
( (V_5 / ( V_1 * B * w)) * 1e-4 )**2 +\
( (V_5 * l / ( V_1 * B * w)) * 1e-4 )**2 +\
( (V_5 * l / ( V_1**2 * B * w)) * V_1e )**2 +\
( (V_5 * l / ( V_1 * B**2 * w)) * 2e-8 )**2 +\
( (V_5 * l / ( V_1 * B * w**2)) * 1e-4 )**2)
x5, x1, V5, V1, N5, N1 = [], [], [], [], [], []
for df in data_files1:
databox = spinmob.data.load(df)
x, V, N = interpolate(databox)
x5 += x
V5 += V
N5 += N
for df in data_files2:
databox = spinmob.data.load(df)
x, V, N = interpolate(databox)
x1 += x
V1 += V
N1 += N
min_len = min([len(x5), len(x1)])
xs = pylab.array(x5[:min_len])
V5, V1 = pylab.array(V5[:min_len]), pylab.array(V1[:min_len])
N5, N1 = pylab.array(N5[:min_len]), pylab.array(N1[:min_len])
e5, e1 = err / pylab.sqrt(N5), err / pylab.sqrt(N1)
ys, es = mu_H(V5, V1), mu_He(V5, V1, e5, e1)
make_fig(xs, ys, es, outfile)
def calibrate_delay(requested_time):
for n_points in itertools.count(5000, 1000):
args = generate_params(n_points)
time_started = time.time()
interpolate(*args)
if time.time() - time_started > requested_time:
return args
def calibrate_delay(requested_time):
for n_points in itertools.count(5000, 1000):
args = generate_params(n_points)
time_started = time.time()
interpolate(*args)
if time.time() - time_started > requested_time:
return args
def correlationTest(arr1, arr2, display=False):
print "correlation test"
if display:
print 'arr1'
showArrayWithAxes(arr=arr1)
print 'arr2'
showArrayWithAxes(arr=arr2)
i_arr1, j_arr1 = getCentroid(arr1)
i_arr2, j_arr2 = getCentroid(arr2)
M1 = getMomentMatrix(arr1, display=display)
M2 = getMomentMatrix(arr2, display=display)
eigenvalues1, eigenvectors1 = getAxes(M1, display=display)
eigenvalues2, eigenvectors2 = getAxes(M2, display=display)
arr1_coords = transform(arr1, i_arr1, j_arr1, eigenvectors=eigenvectors1,
eigenvalues=eigenvalues1)
arr2_coords = transform(arr2, i_arr2, j_arr2, eigenvectors=eigenvectors2,
eigenvalues=eigenvalues2)
arr1_transformed = interpolate(arr1, arr1_coords[0], arr1_coords[1])
arr2_transformed = interpolate(arr2, arr2_coords[0], arr2_coords[1])
correlation = getCorrelation(arr1_transformed, arr2_transformed)
if display:
print 'arr1_transformed'
showArrayWithAxes(arr1_transformed)
print 'arr2_transformed'
showArrayWithAxes(arr2_transformed)
print 'correlation', correlation
print 'arr1.sum()', arr1.sum()
print 'arr2.sum()', arr2.sum()
print 'arr1_transformed.sum()', arr1_transformed.sum()
print 'arr2_transformed.sum()', arr2_transformed.sum()
return_value= {'correlation':correlation, 'arr1_transformed': arr1_transformed,
'arr2_transformed': arr2_transformed, }
return return_value
def my_optimization(data):
p = data[0]
big_R = data[1]
small_r = data[2]
#set up boundary condition
g = Constant(0.0)
bc = DirichletBC(Q, g, DirichletBoundary())
#Define initial condition
indata = Expression(
"pow(big_R-sqrt(pow(x[0],2)+pow(x[1],2)),2)+pow(x[2],2)<=pow(small_r,2) ? p : 0",
degree=3,
small_r=small_r,
big_R=big_R,
p=p) #enter initial condition
u0 = Function(Q)
u0 = interpolate(indata, Q)
# Define variational problem
u = TrialFunction(Q)
v = TestFunction(Q)
f = Constant(0.0)
#copy initial data
u_initial = Function(Q)
u_initial = interpolate(indata, Q)
#form finite element
a = u * v * dx + alpha * dt * dot(grad(u), grad(v)) * dx
L = (u0 + dt * f) * v * dx
u = u0
t = 0.0
save_t = []
save_mass = []
i = 0
while t < T:
t += dt
save_t.append(t)
solve(a == L, u, bc)
M = (u_initial - u) * dx
mass = assemble(M)
save_mass.append(mass)
u0.assign(u)
mass_interpolate = scipy.interpolate.interp1d(save_t, save_mass)
#key time {5, 7, 30}
#compare with target {10, 15, 30}
M5 = mass_interpolate(5.0)
M7 = mass_interpolate(7.0)
M30 = mass_interpolate(30.0)
F = (M5 - 10.0)**2 + (M7 - 15.0)**2 + (M30 - 30.0)**2
return F
def getMinimaSpline(minima, minimaValues, data):
if len(minima) >= 4:
minimaSpline = interpolate(minima, minimaValues, len(data),3)
elif len(minima) == 3:
minimaSpline = interpolate(minima, minimaValues, len(data,),2)
else:
minimaSpline = interpolate(minima, minimaValues, len(data),1)
return minimaSpline
def getMinimaSpline(minima, minimaValues, data):
if len(minima) >= 4:
minimaSpline = interpolate(minima, minimaValues, len(data), 3)
elif len(minima) == 3:
minimaSpline = interpolate(minima, minimaValues, len(data, ), 2)
else:
minimaSpline = interpolate(minima, minimaValues, len(data), 1)
return minimaSpline
def LS_CE(Y,pilotValue,pilotCarriers,K,P,int_opt):
index = np.arange(P)
LS_est = np.zeros(P, dtype=complex)
LS_est[index] = Y[pilotCarriers] / pilotValue[index] #complex
if int_opt == 0:
H_LS = interpolate(LS_est,pilotCarriers,K,0)
if int_opt == 1:
H_LS = interpolate(LS_est,pilotCarriers,K,1)
return H_LS
def _insert_by_distance(self, interpol_type='quadratic'):
"""Inserts nodes if distance exceeds par.MAX_SEGLEN"""
# Raise Error if points not in strict ascending order.
if np.any(self.x[1:] <= self.x[:-1]):
index = tuple(np.where(self.x[1:] <= self.x[:-1])[0])
# self.x = np.delete(self.x, index)
# self.y = np.delete(self.y, index)
raise ValueError(
'Adaptive Grid: Nodes not in strictly ascending order at indices:',
index)
# Calculate distances of nodes
x_dist = np.abs(self.x[1:] - self.x[:-1])
y_dist = np.abs(self.y[1:] - self.y[:-1])
distance = np.insert(np.sqrt(x_dist**2 + y_dist**2), 0, 0)
# Find where and how many nodes to insert by distance criteria
dist_index, = np.where(distance > par.MAX_SEGLEN)
# insert_nodes = np.floor_divide(distance[dist_index], par.MAX_SEGLEN)
insert_nodes = np.int32(np.ceil(distance[dist_index] / par.MAX_SEGLEN))
new_points = np.split(self.x, dist_index)
# Insert equally spaced points in x-axis
for i in range(len(dist_index)):
line = np.linspace(self.x[dist_index[i] - 1],
self.x[dist_index[i]],
insert_nodes[i] + 1,
endpoint=True)
line = line[1:-1]
new_points[i] = np.append(new_points[i], line)
interpolate = scipy.interpolate.interp1d(self.x, self.y, interpol_type)
self.x = np.concatenate(new_points)
self.y = interpolate(self.x)
def convolve_gaussian(x, y, cw, fwhm, integrate=False, points=10):
"""\
Convolve x,y with cw,fwhm.
"""
x = np.asarray(x, dtype='f8')
y = np.asarray(y, dtype='f8')
cw = np.asarray(cw, dtype='f8')
fwhm = np.asarray(fwhm, dtype='f8')
if np.std(np.diff(x)) / np.mean(np.diff(x)) > 1e-9:
print(np.std(np.diff(x)), np.mean(np.diff(x)))
print('x need to be equidistant!')
if integrate:
ssi = sampling_interval(cw)
z = []
for i in range(cw.size):
wmin = cw[i] - 0.5 * ssi[i]
wmax = cw[i] + 0.5 * ssi[i]
w = np.linspace(wmin, wmax, points)
h = interpolate(w, cw, fwhm, k=3)
zi = np.mean(convx.convolve(x, y, w, h, 'gauss'))
z.append(zi)
return np.array(z)
else:
return convx.convolve(x, y, cw, fwhm, 'gauss')
def make_graph(calib, results, technique):
fig = plt.figure()
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
calib_xy = tuple(zip(*calib))
results_yx = tuple(zip(*results))
ymin = min(calib[0][1], results[0][0])
ymax = max(calib[-1][1], results[-1][0])
ys = range(int(ymin), int(ymax + 1))
interp_results = interpolate(ys, technique, calib)
ax.plot(tuple(zip(*interp_results))[1],
ys,
color="cyan",
label="calibration curve")
ax.plot(results_yx[1],
results_yx[0],
"+",
mec="black",
mew=0.5,
label="interpolated step")
ax.plot(calib_xy[0],
calib_xy[1],
"o",
mfc="none",
mec="red",
label="calibration point")
ax.legend(loc="best")
plt.savefig("test.pdf")
def compute_ctf(self):
r = int(round(float(self.radius), 0))
ctf_final = []
bounds = np.linspace(0, r, r)
ang, val = interpolate(self, 3)
N = len(ang)
ctf = np.absolute(scipy.fftpack.fft(val - np.mean(val)))
func = 2.0 / N * np.abs(ctf[:N // 2])
max = np.amax(func)
# print(ind)
qf = find_main_peak(self)
for ri in bounds:
xf, yf, N, func = get_fft(self, ri)
peaks, indexes = find_peaks(self)
ap = 0.0
for peak in range(len(peaks)):
if abs(peaks[peak] - qf) < 0.01:
ap = func[indexes[peak]]
ctf_final.append(ap)
xr = np.linspace(0, r, r)
db_3_interp = np.interp(0.5 * max, ctf_final, xr)
return qf * 1 / xr, ctf_final, qf * 1 / db_3_interp, qf * 1 / self.radius, max
def run(self, wpRs=None, wpts=None):
run = True
while run:
run, wpRs, wpts = self.create_waypoints(wpRs, wpts)
if run:
self.playback_waypoints(*interpolate(wpRs, wpts))
return wpRs, wpts
def compute_trsfs(p):
# Create the output folder for the transfomrations
if not os.path.exists(p.trsf_folder):
os.makedirs(p.trsf_folder)
trsf_fmt = 't{flo:06d}-{ref:06d}.txt'
try:
run_produce_trsf(p, nb_cpu=1)
if p.sequential:
if min(p.to_register) != p.ref_TP:
compose_trsf(min(p.to_register), p.ref_TP, p.trsf_folder,
list(p.to_register))
if max(p.to_register) != p.ref_TP:
compose_trsf(max(p.to_register), p.ref_TP, p.trsf_folder,
list(p.to_register))
np.savetxt(('{:s}' + trsf_fmt).format(p.trsf_folder,
flo=p.ref_TP,
ref=p.ref_TP), np.identity(4))
except Exception as e:
print(p.trsf_folder)
print(e)
if p.lowess:
trsf_fmt = lowess_filter(p, trsf_fmt)
if p.trsf_interpolation:
trsf_fmt = interpolate(p, trsf_fmt)
if p.padding:
pad_trsfs(p, trsf_fmt)
def generate_object(job_id: int):
# generate mesh with equally distributed points on surface
mesh, n_points = generate_unity_sphere(settings.n_iter)
r0, phi0, theta0 = cartesian_to_spherical_coordinates(
*points_to_xyz(mesh['points']))
# generate random radii
r, theta, phi = generate_random_radii(
settings.f_max, settings.n_pnts,
settings.frequency_power_decrease_rate)
# map random radii on the equal distributed mesh
r_new = interpolate(theta, phi, r, theta0, phi0)
# change the mesh
mesh['points'] = np.vstack(
spherical_to_cartesian_coordinates(r_new, theta0, phi0)).T
# create and save step file
step_file = generate_step_file(mesh)
with open(constants.SrcPaths.object(job_id), 'w') as file:
file.write(step_file)
convert_shell_stp_to_object_stp(constants.SrcPaths.object(job_id))
# return the mesh
return mesh
def curved_line(endpoints):
"""Draws a curved line between the endpoints."""
p = np.array([
endpoints[0,:],
# in the middle is the midpoint, except a bit higher up
np.mean(endpoints, axis=0) + (0, 0.4),
endpoints[1,:] ])
return interpolate(p)
def drawPlot(self, mode):
plt.figure()
ang, val = interpolate(self, mode)
r = int(round(self.radius, 0))
plt.plot(ang, val, label='r={}'.format(r))
plt.xlabel('degrees from polar axis at r')
plt.ylabel('pixel greyscale values')
plt.show()
def map_profile_onto_turb_grid(self, profileTango):
"""Since Tango's domain is larger than GENE's in both directions, we can use a simple interpolating spline to
resample the profile on GENE's grid.
"""
interpolate = scipy.interpolate.InterpolatedUnivariateSpline(
self.psiTango, profileTango)
profileGene = interpolate(self.psiGene)
return profileGene
def test_interpolation_with_given_weights():
for rank in [2, 3, 4, 5, 6, 7]:
for degree in [1, 2, 3]:
if degree >= rank - 1:
break
sizes = np.random.randint(5, 10, rank)
t = np.random.randn(*sizes)
weights = np.ones(degree)
indices = np.array(
[np.random.randint(max(s - 1, 0)) for s in sizes[:degree]])
r = interpolate(t, weights, indices)
assert (np.all(np.isclose(r, t[tuple(indices)])))
weights = np.zeros(degree)
r = interpolate(t, weights, indices)
assert (np.all(np.isclose(r, t[tuple([i + 1 for i in indices])])))
def createsurface(pts,
mode='thin_plate',
rbfmode=True,
gridCount=20,
zfactor=1,
bound=10**5,
matplot=False):
modeColor = {
'linear': (1.0, 0.3, 0.0),
'thin_plate': (0.0, 1.0, 0.0),
'cubic': (0.0, 1.0, 1.0),
'inverse': (1.0, 1.0, 0.0),
'multiquadric': (1.0, .0, 1.0),
'gaussian': (1.0, 1.0, 1.0),
'quintic': (0.5, 1.0, 0.0)
}
x = [v[1] for v in pts]
y = [v[0] for v in pts]
z = [zfactor * v[2] for v in pts]
x = np.array(x)
y = np.array(y)
z = np.array(z)
gridsize = gridCount
rbf, xi, yi, zi1 = interpolate(x, y, z, gridsize, mode, rbfmode)
# hilfsebene
xe = [100, -100, 100, -100]
ye = [100, 100, -100, -100]
ze = [20, 10, 20, 5]
rbf2, xi2, yi2, zi2 = interpolate(xe, ye, ze, gridsize, mode, rbfmode,
zi1.shape)
zi = zi1
color = (1.0, 0.0, 0.0)
showFace(rbf, rbf2, x, y, gridsize, color, bound)
App.ActiveDocument.ActiveObject.Label = mode + " ZFaktor " + str(
zfactor) + " #"
rc = App.ActiveDocument.ActiveObject
def createElevationGrid(pts,mode='thin_plate',rbfmode=True,source=None,gridCount=20,zfactor=1,bound=10**5,matplot=False):
modeColor={
'linear' : ( 1.0, 0.3, 0.0),
'thin_plate' : (0.0, 1.0, 0.0),
'cubic' : (0.0, 1.0, 1.0),
'inverse' : (1.0, 1.0, 0.0),
'multiquadric' : (1.0, .0, 1.0),
'gaussian' : (1.0, 1.0, 1.0),
'quintic' :(0.5,1.0, 0.0)
}
k=0.0001
k=0
pts2=[p+FreeCAD.Vector(random.random(),random.random(),random.random())*k for p in pts]
pts=pts2
#say("points",pts)
x=np.array(pts)[:,0]
y=np.array(pts)[:,1]
z=np.array(pts)[:,2]
say(x)
say(y)
say(z)
say("----------")
#x=np.array(x)
#y=np.array(y)
#z=np.array(z)
gridsize=gridCount
rbf,xi,yi,zi1 = interpolate(x,y,z, gridsize,mode,rbfmode)
# hilfsebene
xe=[10,-10,10,-10]
ye=[10,-9,10,-10]
ze=[0,0,0,0]
#rbf2,xi2,yi2,zi2 = interpolate(xe,ye,ze, gridsize,mode,rbfmode,zi1.shape)
rbf2=0
#zi=zi1-zi2
zi=zi1
try: color=modeColor[mode]
except: color=(1.0,0.0,0.0)
xmin=np.min(x)
ymin=np.min(y)
points=showFace(rbf,rbf2,x,y,gridsize,color,bound)
say("XXXX points",points)
return points
def segmentize(start, end, maxLength):
l = distance(start, end)
if l <= maxLength:
return [end]
else:
output = []
n = int(math.ceil(l / maxLength))
for i in range(1, n + 1):
output.append(interpolate(start, end, i, n))
return output
def animate(i):
i = 40*i
x = Ix2
y = np.zeros(len(Ix2))
z = interpolate(sol_left[i,:],sol_right[i,:],sol_val[i,:],Ix)
for i in range(len(Ix2)):
y[i] = np.average(z[40*i:40*(i+1)])
line.set_data(x, y)
#ax.set_title('t = {0}s'.format(str(np.around(dt*i*100,decimals=2))))
return line,
def segmentize(start,end,maxLength):
l=distance(start,end)
if l<=maxLength:
return [end]
else:
output=[]
n=int(math.ceil(l/maxLength))
for i in range(1,n+1):
output.append(interpolate(start,end,i,n))
return output
def fftconvolve(x,y,yres,xres=None,normalize=False):
if (xres is not None):
yres = interpolate(xres,yres,x,fill_value=0)
fft = scipy.signal.fftconvolve(y,yres,"full")
_idx = np.argmin( np.abs(x) ); # find t=0
fft = fft[_idx:_idx+len(x)]
if normalize:
norm = fftconvolve_find_norm(x,yres,xres=None)
else:
norm = 1
return fft/norm
def envelope(signal: np.ndarray, x: np.ndarray = None, top=True, iterations=1):
if x is None:
x = np.arange(len(signal))
comparator = np.greater if top else np.less
for i in range(iterations):
# noinspection PyUnresolvedReferences
local_extrema = sp.signal.argrelextrema(signal, comparator)[0]
signal = interpolate(local_extrema, signal[local_extrema], x)
return signal
def align_graph(graph):
al = GraphAlignment(graph)
points, edges = al.align()
points = GraphAlignment.normalize_points(points)
pts = []
for i in xrange(len(points)):
pts.append(points[i])
edges = interpolate(pts, edges)
print "got points %s" % len(pts)
return pts, edges
def regrid(a, b):
"""
a is the object to be resized
b provides the relevant shape information for the process
"""
gridSizeOld = a.matrix.shape
gridSizeNew = b.matrix.shape
height, width = gridSizeNew
X, Y = np.meshgrid(range(width), range(height))
J, I = X, Y
# I, J = I_new, J_new
a_new = DBZ(name=a.name+"rescaled to "+str(gridSizeNew),
matrix = np.zeros(gridSizeNew),
lowerLeftCornerLatitudeLongitude=b.lowerLeftCornerLatitudeLongitude,
)
latOld, longOld = a.lowerLeftCornerLatitudeLongitude
latNew, longNew = b.lowerLeftCornerLatitudeLongitude
latDegreePerGridOld = 1.*(a.upperRightCornerLatitudeLongitude[0]-latOld)/gridSizeOld[0]
longDegreePerGridOld= 1.*(a.upperRightCornerLatitudeLongitude[1]-longOld)/gridSizeOld[1]
latDegreePerGridNew = 1.*(b.upperRightCornerLatitudeLongitude[0]-latOld)/gridSizeNew[0]
longDegreePerGridNew= 1.*(b.upperRightCornerLatitudeLongitude[0]-longOld)/gridSizeNew[1]
#I_old = (1.* I/gridSizeNew[0]+latNew -latOld) * gridSizeOld[0] # this is wrong
#J_old = (1.* J/gridSizeNew[0]+latNew -latOld) * gridSizeOld[0] # we should convert
# with the degree per grid
# as the replacement below
I_old = (1.* I*latDegreePerGridNew +latNew -latOld) / latDegreePerGridOld
J_old = (1.* J*longDegreePerGridNew +longNew -longOld) /longDegreePerGridOld
# debug
print I, J
print I_old, J_old, I_old.shape
print "latDegreePerGridOld , longDegreePerGridOld", latDegreePerGridOld , longDegreePerGridOld
print "latDegreePerGridNew , longDegreePerGridNew", latDegreePerGridNew , longDegreePerGridNew
print "gridSizeOld", gridSizeOld
print "gridSizeNew", gridSizeNew
print "I_old[0,0], J_old[0,0]", I_old[0,0], J_old[0,0]
testmat = np.zeros((1000,1000))
for ii in range(I_old.shape[0]):
for jj in range(I_old.shape[1]):
testmat[I_old[ii,jj]*(I_old[ii,jj]>0), J_old[ii,jj]*(J_old[ii,jj]>0)] = 1
from matplotlib import pyplot as plt
plt.imshow(testmat)
plt.show()
# end debug
arr_old = a.matrix
arr_new = np.zeros((height, width))
a_new.matrix = interpolate(arr_old, arr_new, I_old, J_old)
return a_new
def do_subtract_dataset(self, dataset, object_):
'''
Subtract one dataset from another using interpolation.
'''
from copy import deepcopy
interpolate=scipy.interpolate.interp1d
xdata=numpy.array(dataset.data[dataset.xdata].values)
ydata=numpy.array(dataset.data[dataset.ydata].values)
error=numpy.array(dataset.data[dataset.yerror].values)
x2data=numpy.array(object_.data[object_.xdata].values)
y2data=numpy.array(object_.data[object_.ydata].values)
error2=numpy.array(object_.data[object_.yerror].values)
if x2data[0]>x2data[-1]:
x2data=numpy.array(list(reversed(x2data.tolist())))
y2data=numpy.array(list(reversed(y2data.tolist())))
error2=numpy.array(list(reversed(error2.tolist())))
func2=interpolate(x2data, y2data, kind='cubic', bounds_error=False, fill_value=0.)
efunc2=interpolate(x2data, error2, kind='cubic', bounds_error=False, fill_value=0.)
y2interp=func2(xdata)
error2interp=efunc2(xdata)
x2_start=x2data.min()
x2_stop=x2data.max()
y2_start=y2data[0]
y2_stop=y2data[-1]
e2_start=error2[0]
e2_stop=error2[-1]
for i, x in enumerate(xdata):
if x<x2_start:
y2interp[i]=y2_start
error2interp[i]=e2_start
if x>x2_stop:
y2interp[i]=y2_stop
error2interp[i]=e2_stop
newdata=deepcopy(dataset)
newdata.data[newdata.ydata].values=(ydata-y2interp).tolist()
newdata.data[newdata.yerror].values=(numpy.sqrt(error**2+error2interp**2)).tolist()
newdata.short_info=dataset.short_info+' - '+object_.short_info
return newdata
def make_graph(calib, results, technique):
fig = plt.figure()
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
calib_xy = tuple(zip(*calib))
results_yx = tuple(zip(*results))
ymin = min(calib[0][1], results[0][0])
ymax = max(calib[-1][1], results[-1][0])
ys = range(int(ymin), int(ymax+1))
interp_results = interpolate(ys, technique, calib)
ax.plot(tuple(zip(*interp_results))[1], ys, color="cyan", label="calibration curve")
ax.plot(results_yx[1], results_yx[0], "+", mec="black", mew=0.5, label="interpolated step")
ax.plot(calib_xy[0], calib_xy[1], "o", mfc="none", mec="red", label="calibration point")
ax.legend(loc="best")
plt.savefig("test.pdf")
def interpolate_file_old(filename, low, high, dt):
numlines = 0
infile = open(filename)
for l in infile:
if l[0] == '#':
continue
numlines += 1
infile.close()
old_ts = numpy.zeros(numlines)
new_ts = numpy.arange(low, high, dt)
old_amp = numpy.zeros(numlines)
old_phi = numpy.zeros(numlines)
infile = open(filename)
idx = 0
for l in infile:
if l[0] == '#':
continue
old_ts[idx], old_amp[idx], old_phi[idx] = map(float,l.strip().split())
idx += 1
infile.close()
new_amp = interpolate(old_ts, new_ts, old_amp)
new_phi = interpolate(old_ts, new_ts, old_phi)
hplus = new_amp * numpy.cos(new_phi)
hcross = new_amp * numpy.sin(new_phi)
outfile = open(filename.replace('.minimal',''), 'w')
for t, hp, hc in zip(new_ts, hplus, hcross):
print >>outfile, '%f %e %e' % (t, hp, hc)
outfile.close()
def _mcmc_lnprob(p,dspec,dspecerr,
teff,logg,vm,metals,cm,nm,am,
fixteff,fixlogg,fixvm,fixmetals,fixcm,fixnm,fixam,
sixd,pca,dr,lib,inter,f_format,f_access):
# First fill in the fixed parameters
parIndx= 0
if fixteff:
tteff= teff*numpy.ones(len(p))
else:
tteff= p[:,parIndx]
parIndx+= 1
if fixlogg:
tlogg= logg*numpy.ones(len(p))
else:
tlogg= p[:,parIndx]
parIndx+= 1
if fixvm and not sixd:
tvm= vm*numpy.ones(len(p))
elif sixd:
tvm= None
else:
tvm= 10.**p[:,parIndx]
parIndx+= 1
if fixmetals:
tmetals= metals*numpy.ones(len(p))
else:
tmetals= p[:,parIndx]
parIndx+= 1
if fixcm:
tcm= cm*numpy.ones(len(p))
else:
tcm= p[:,parIndx]
parIndx+= 1
if fixnm:
tnm= nm*numpy.ones(len(p))
else:
tnm= p[:,parIndx]
parIndx+= 1
if fixam:
tam= am*numpy.ones(len(p))
else:
tam= p[:,parIndx]
# Get the interpolated spectra
ispec= interpolate(tteff,tlogg,tmetals,tam,tnm,tcm,vm=tvm,
sixd=True,apStarWavegrid=False,dr=dr,pca=pca,
lib=lib,inter=inter,f_format=f_format,f_access=f_access)
# Compute the chi^2
chi2= _chi2(ispec,dspec[:len(ispec)],dspecerr[:len(ispec)])
return -chi2/2.
def get_multid_data(data):
data_data = [get_data(d) for d in data]
x_vals, y_vals = interpolate(data_data, sampling_freq=3600)
out_data = y_vals
ret_data = []
for index in range(len(out_data[0])):
found_nan = False
for x in out_data:
if isnan(x[index]):
found_nan = True
break
if found_nan:
continue
ret_data.append([x[index] for x in out_data])
return ret_data
def get_multid_data(data):
data_data = [get_data(d) for d in data]
x_vals, y_vals = interpolate(data_data, sampling_freq=3600)
out_data = y_vals
ret_data = []
for index in range(len(out_data[0])):
found_nan = False
for x in out_data:
if isnan(x[index]):
found_nan = True
break
if found_nan:
continue
ret_data.append([x[index] for x in out_data])
return ret_data
def main():
if len(sys.argv) < 2:
print(' Usage:\n python3 InterpXRange <paramFile>')
print(' Requires python 3.x. Not compatible with python 2.x\n')
return
TFile = os.path.splitext(sys.argv[1])[0]
if dP.setRange:
TFile += '_Interp' + str(dP.rangeMin) + '-' + str(dP.rangeMax) + '.csv'
else:
TFile += '_Interp.csv'
dfP = readParamFile(sys.argv[1])
dfPint = interpolate(dfP)
dfPint.to_csv(TFile, index=True)
def createNurbs(pts4,mode,gridsize): # calculate quadmesh [x,y,z]=np.array(pts4).swapaxes(0,1) # add some noise to avoid singular matrix x+= np.random.random(len(x)) y+= np.random.random(len(x)) x,y=y,x rbfmode=True rbf,xi,yi,zi = interpolate(x,y,z, gridsize,mode,rbfmode) rc=showNurbs(rbf,x,y,gridsize,z.max(),z.min(),mode) #showHeightMap(x,y,z,zi) return rc
def main():
usage = "usage: %prog [options] <calibration_file>"
parser = OptionParser(usage = usage)
parser.add_option("-i", "--interpolation", dest="interp", default="spl",
help="spl spline, pwl piecewise linear, lsq least-squares",
metavar="TYPE")
parser.add_option("-s", "--steps", dest="steps", default="35",
help="number of steps",
metavar="N")
parser.add_option("-m", "--min", dest="min", default="3.3",
help="minimum field (mT)",
metavar="MILLITESLA")
parser.add_option("-a", "--max", dest="max", default="1000",
help="maximum field (mT)",
metavar="MILLITESLA")
parser.add_option("-g", "--graph", dest="graph", default=None,
help="produce a PDF graph of the calibration and steps",
metavar="FILENAME")
parser.add_option("-d", "--distribution", dest="dist", default="exp",
help="step distribution: lin[ear] or exp[onential]",
metavar="TYPE")
(opt, args) = parser.parse_args()
if len(args) != 1:
print("Incorrect number of arguments.")
print(usage)
return
calibration_file = args[0]
calib = make_calibration(calibration_file)
desired_fields = pick_desired_fields(float(opt.min),
float(opt.max),
float(opt.steps),
opt.dist.startswith('e'))
results = interpolate(desired_fields, opt.interp, calib)
for result in results:
print('%6.1f\t%5.1f' % (result[0], result[1]))
if opt.graph:
make_graph(calib, results, opt.interp)
def extend_with_zeros_both_sides(xSmall,
fSmall,
xLarge,
enforcePositive=False):
"""Extending a function to a larger domain, with zeros where it was not originally defined.
The domain xSmall should be fully contained within xLarge. That is, xLarge extends farther outward
on both sides of the domain.
This function operates by resampling within the overlapping region xSmall, and then extending with zeros.
Sometimes, interpolation might produce negative values when zero is the minimum for physical reasons.
The diffusion coefficient is one example where one wants to maintain positivity. In this case, one
can optionally enforce positivity of the returned value by zeroing out negative values.
Inputs:
xSmall independent variable on the smaller domain (array)
fSmall dependent variable on the smaller domain (array)
xLarge independent variable on the larger domain (array)
enforcePositive (optional) If True, set any negative values to zero before returning (boolean)
Outputs:
fLarge dependent variable on the larger domain (array)
"""
assert xLarge[0] <= xSmall[0] and xLarge[-1] >= xSmall[-1]
# resample within the overlapping region
fLarge = np.zeros_like(xLarge) # initialize with zeros
ind = np.where(xLarge > xSmall[0])
indstart = ind[0][0]
ind = np.where(xLarge < xSmall[-1])
indfinal = ind[0][-1]
xLargeTemp = xLarge[indstart:indfinal + 1]
interpolate = scipy.interpolate.InterpolatedUnivariateSpline(
xSmall, fSmall)
fLarge[indstart:indfinal + 1] = interpolate(xLargeTemp)
# extend with zeros -- automatically performed because fLarge was initialized with zeros
if enforcePositive == True:
ind = fLarge < 0
fLarge[ind] = 0
return fLarge
def renormalise(a, display=False):
'''
from armor.geometry import transformedCorrelations as test
reload(test) ; a_ren = test.renormalise(a, display=True)
'''
arr = a.matrix
centroid_i, centroid_j = getCentroid(arr)
M1 = getMomentMatrix(arr)
eigenvalues1, eigenvectors1 = getAxes(M1, display=display)
I, J = transform(arr, centroid_i, centroid_j,
eigenvectors = eigenvectors1,
eigenvalues = eigenvalues1,)
arr_renormalised = interpolate(arr, I, J)
a_renormalised = pattern.DBZ(matrix=arr_renormalised,
name= a.name+'renormalised',
)
if display:
a_renormalised.show4()
return a_renormalised
def r2calc(xMeas, yMeas, xRef, yRef):
"""Calculates the R-squared value for two vectors"""
# =========================================================================
# If the number of y points in the measured and reference vectors are not
# equivalent, iterpolates the measured vector to have the same number of
# data points as the reference spectra.
# =========================================================================
if len(yMeas) != len(yRef):
interpolate = scipy.interpolate.interp1d
yMeas = interpolate(xMeas,
yMeas,
kind='linear',
fill_value='extrapolate')(xRef)
# =========================================================================
# Produces a correlation coefficient matrix of the y values.
# =========================================================================
rMatrix = np.corrcoef(yMeas, yRef)
r2 = rMatrix[0][1]**2
return r2
def calcMagneticFieldMap(self):
"""Calculate the magnetic field map for given solenoid and BC currents."""
if isinstance(self.b_field, tuple):
# Coefficients describing how the B-field depends on the sol/BC currents
X = self.bc_current * self.b_field.bc_turns / self.b_field.bc_area
Y = self.sol_current * self.b_field.sol_turns / self.b_field.sol_area
# Use a subset of coefficients
A = np.array([
Y, Y**2, Y**3, X, X * Y, X * Y**2, X**2, X**2 * Y, X**2 * Y**2,
X**2 * Y**3, X**3, X**3 * Y
]).T
self.B_map = np.dot(self.b_field.coeffs, A)
self.z_map = self.b_field.z_map
else:
# we've defined it as just an array, multiply by sol current to get field
self.z_map, B_map = self.b_field
self.B_map = B_map * self.sol_current
self.B_interp = interpolate(self.z_map, self.B_map)
self.calc_done = True
def determing_rms_for_surrounding_atoms(sts):
# change of rms on each step compared to first structure
#here first and last structures should correspond to first and last images
st1 = sts[0]
st_interp = interpolate(sts[0], sts[-1], 1)[0]
rms_list = []
for st in sts:
rms = rms_pos_diff(st_interp, st)
rms_list.append(rms)
print('rms is {:.3f}'.format(rms))
print('d rms is {:.3f}'.format(abs(rms_list[3] - rms_list[0])))
rms_change = abs(min(rms_list) - max(rms_list))
return rms_change
def swipe(self,
x0,
y0,
x1,
y1,
move_duraion=1,
hold_before_release=0,
interpolation='linear'):
if interpolation == 'linear':
interpolate = lambda x: x
elif interpolation == 'spline':
import scipy.interpolate
xs = [0, random.uniform(0.7, 0.8), 1, 2]
ys = [0, random.uniform(0.9, 0.95), 1, 1]
tck = scipy.interpolate.splrep(xs, ys, s=0)
interpolate = lambda x: scipy.interpolate.splev(x, tck, der=0)
frame_time = 1 / 100
start_time = time.perf_counter()
end_time = start_time + move_duraion
self.scrcpy.control.touch(x0, y0, scrcpy_const.ACTION_DOWN)
t1 = time.perf_counter()
step_time = t1 - start_time
if step_time < frame_time:
time.sleep(frame_time - step_time)
while True:
t0 = time.perf_counter()
if t0 > end_time:
break
time_progress = (t0 - start_time) / move_duraion
path_progress = interpolate(time_progress)
self.scrcpy.control.touch(int(x0 + (x1 - x0) * path_progress),
int(y0 + (y1 - y0) * path_progress),
scrcpy_const.ACTION_MOVE)
t1 = time.perf_counter()
step_time = t1 - t0
if step_time < frame_time:
time.sleep(frame_time - step_time)
self.scrcpy.control.touch(x1, y1, scrcpy_const.ACTION_MOVE)
if hold_before_release > 0:
time.sleep(hold_before_release)
self.scrcpy.control.touch(x1, y1, scrcpy_const.ACTION_UP)
def main():
parser = script_parser()
(options, args) = parser.parse_args()
if len(args)!=1: # print the help message if number of args is not one.
parser.print_help()
sys.exit()
optdic = vars(options)
filein = args[0]
navlon,navlat,data = read(filein,**optdic)
if optdic['showmap'] is True:
plt.pcolormesh(navlon,navlat,data)
plt.colorbar()
plt.show()
x_reg,y_reg,data_reg = interpolate(data,navlon,navlat,interp=optdic['interp'])
pspec,kstep = get_spectrum_1d(data_reg,x_reg,y_reg)
if optdic['plotname']=='0':
return pspec,kstep
else:
plot_spectrum(pspec,kstep,**optdic)
return
def main():
parser = script_parser()
(options, args) = parser.parse_args()
if len(args)!=1: # print the help message if number of args is not one.
parser.print_help()
sys.exit()
optdic = vars(options)
filein = args[0]
navlon,navlat,data = read(filein,**optdic)
if optdic['showmap'] is True:
plt.pcolormesh(navlon,navlat,data)
plt.colorbar()
plt.show()
x_reg,y_reg,data_reg = interpolate(data,navlon,navlat,interp=optdic['interp'])
pspec,kstep = get_spectrum_1d(data_reg,x_reg,y_reg)
if optdic['plotname']=='0':
return pspec,kstep
else:
plot_spectrum(pspec,kstep,**optdic)
return
def main():
try:
f = open(sys.argv[1], "r")
lines = f.readlines()
f.close()
except IndexError:
print "\nusage: " + sys.argv[0] + " TPZ.dat\n"
sys.exit(0)
T, P, z, count = [], [], [], -1
for line in lines:
row = line.split()
if float(row[0]) not in T:
T.append(float(row[0]))
P.append([])
z.append([])
count += 1
P[count].append(float(row[1]))
z[count].append(float(row[2]))
# Interpolate
dP = 10.0
Pmin = 0.0
Pmax = 200.0
P_new = numpy.arange(Pmin, Pmax, dP / 10.0)
z_new = []
for i in range(len(z)):
tck = interpolate.splrep(P[i], z[i], s=0, k=1) # s=0: no smoothing, k=1: linear spline
z_new.append(interpolate(P_new, tck))
z_new = numpy.array(z_new)
fig = pylab.figure(figsize=(12, 6), facecolor="w", edgecolor="k")
pylab.contourf(P_new, T, z_new, 10, linewidth=0.05)
pylab.xlim((max(y), 1.22))
pylab.colorbar()
pylab.savefig("test.png")
sall_time = asarray(all_time)
#print sall_time[3]
sall_current = asarray(all_current)
#print sall_current[3]
new_currents = []
with open(result_file,'wb') as ofile:
for new_point in new_points:
new_current = mini_interpolate(original_file,new_point)
new_currents.append(new_current)
ofile.write('%e %e\n' % (new_point,new_current))
#splrepint = interpolate.splrep(sall_time, sall_current)
# splrepint = interpolate.splrep(sall_time, sall_current, s=0)
# currentnew = interpolate.splev(snew_points, splrepint, der=0)
# index = 0
# for icurrentnew in currentnew:
# print index,new_points[index],currentnew[index]
if __name__ == "__main__":
if (len(sys.argv)!=4):
print "Usage:",sys.argv[0],"<original file> <points file> <new results file>"
exit(2)
original_filename = sys.argv[1]
points_filename = sys.argv[2]
new_filename = sys.argv[3]
interpolate(original_filename,points_filename,new_filename)
print "interpolated file is:", new_filename
def regrid(a, b):
"""
a is the object to be resized
b provides the relevant shape information for the process
"""
gridSizeOld = a.matrix.shape
gridSizeNew = b.matrix.shape
height, width = gridSizeNew
X, Y = np.meshgrid(range(width), range(height))
J, I = X, Y
# I, J = I_new, J_new
latOld, longOld = a.lowerLeftCornerLatitudeLongitude
latNew, longNew = b.lowerLeftCornerLatitudeLongitude
latDegreePerGridOld = 1.*(a.upperRightCornerLatitudeLongitude[0]-latOld)/gridSizeOld[0]
longDegreePerGridOld= 1.*(a.upperRightCornerLatitudeLongitude[1]-longOld)/gridSizeOld[1]
latDegreePerGridNew = 1.*(b.upperRightCornerLatitudeLongitude[0]-latNew)/gridSizeNew[0]
longDegreePerGridNew= 1.*(b.upperRightCornerLatitudeLongitude[1]-longNew)/gridSizeNew[1]
#I_old = (1.* I/gridSizeNew[0]+latNew -latOld) * gridSizeOld[0] # this is wrong
#J_old = (1.* J/gridSizeNew[0]+latNew -latOld) * gridSizeOld[0] # we should convert
# with the degree per grid
# as the replacement below
I_old = 1.* (I*latDegreePerGridNew +latNew -latOld) / latDegreePerGridOld
J_old = 1.* (J*longDegreePerGridNew +longNew -longOld) /longDegreePerGridOld
# debug
#print I, J
#print I_old, J_old, I_old.shape
#return I_old, J_old #debug
#print "latDegreePerGridOld , longDegreePerGridOld", latDegreePerGridOld , longDegreePerGridOld
#print "latDegreePerGridNew , longDegreePerGridNew", latDegreePerGridNew , longDegreePerGridNew
#print "gridSizeOld", gridSizeOld
#print "gridSizeNew", gridSizeNew
#print "I_old[0,0], J_old[0,0]", I_old[0,0], J_old[0,0]
#testmat = np.zeros((1000,1000))
#for ii in range(I_old.shape[0]):
# for jj in range(I_old.shape[1]):
# testmat[I_old[ii,jj]*(I_old[ii,jj]>0), J_old[ii,jj]*(J_old[ii,jj]>0)] = 1
#from matplotlib import pyplot as plt
#plt.imshow(testmat)
#plt.show()
# end debug
arr_old = a.matrix
arr_new = np.zeros((height, width))
a_new_matrix = interpolate(arr_old, arr_new, I_old, J_old)
a_new_matrix = a_new_matrix.view(ma.MaskedArray)
a_new_matrix.fill_value = -999
a_new_matrix.mask = (a_new_matrix < missingDataThreshold) # anything below " missingDataThreshold is marked as "masked"
# have to do it here
# since the mask is constructed in pattern
# in the pattern.load() function
# which is not called here
a_new = DBZ(name=a.name+" regridded to "+str(gridSizeNew) +\
"\nwith lowerleft corner" + str(b.lowerLeftCornerLatitudeLongitude),
matrix = a_new_matrix,
dataTime = a.dataTime,
lowerLeftCornerLatitudeLongitude=b.lowerLeftCornerLatitudeLongitude,
upperRightCornerLatitudeLongitude=b.upperRightCornerLatitudeLongitude,
coordinateOrigin = b.coordinateOrigin
)
return a_new
def interpolateAlongCurve(curve, t, **kwargs):
"""Interpolate along curve.
Return curve coordinates for a piecewise linear curve :math:`C(t) = {x_i,y_i,z_i}`
at positions :math:`t`.
Curve and :math:`t` values are expected to be sorted along distance from the
origin of the curve.
Parameters
----------
curve : [[x,z]] | [[x,y,z]] | [:gimliapi:`GIMLI::RVector3`] | :gimliapi:`GIMLI::R3Vector`
Discrete curve for 2D :math:`x,z` curve=[[x,z]], 3D :math:`x,y,z`
t : 1D iterable
Query positions along the curve in absolute distance
kwargs :
If kwargs are given an additional curve smoothing is applied using
:py:mod:`pygimli.meshtools.interpolate`. The kwargs will be delegated.
Returns
-------
p : np.array
Curve positions at query points :math:`t`.
Dimension of p match the size of curve the coordinates.
Examples
--------
>>> # no need to import matplotlib. pygimli's show does
>>> import numpy as np
>>> import pygimli as pg
>>> import pygimli.meshtools as mt
>>> fig, axs = pg.plt.subplots(2,2)
>>> topo = np.array([[-2., 0.], [-1., 0.], [0.5, 0.], [3., 2.], [4., 2.], [6., 1.], [10., 1.], [12., 1.]])
>>> t = np.arange(15.0)
>>> p = mt.interpolateAlongCurve(topo, t)
>>> _= axs[0,0].plot(topo[:,0], topo[:,1], '-x', mew=2)
>>> _= axs[0,1].plot(p[:,0], p[:,1], 'o', color='red') #doctest: +ELLIPSIS
>>>
>>> p = mt.interpolateAlongCurve(topo, t, method='spline')
>>> _= axs[1,0].plot(p[:,0], p[:,1], '-o', color='black') #doctest: +ELLIPSIS
>>>
>>> p = mt.interpolateAlongCurve(topo, t, method='harmonic', nc=3)
>>> _= axs[1,1].plot(p[:,0], p[:,1], '-o', color='green') #doctest: +ELLIPSIS
>>>
>>> pg.plt.show()
>>> pg.wait()
"""
xC = np.zeros(len(curve))
yC = np.zeros(len(curve))
zC = np.zeros(len(curve))
tCurve = kwargs.pop('tCurve', None)
if tCurve is None:
tCurve = pg.utils.cumDist(curve)
dim = 3
## extrapolate starting overlaps
if min(t) < min(tCurve):
d = pg.RVector3(curve[1]) - pg.RVector3(curve[0])
#d[2] = 0.0
d.normalise()
curve = np.insert(curve, [0],
[curve[0] - np.array(d*(min(tCurve)-min(t)))[0:curve.shape[1]]],
axis=0)
tCurve = np.insert(tCurve, 0, min(t), axis=0)
## extrapolate ending overlaps
if max(t) > max(tCurve):
d = pg.RVector3(curve[-2]) - pg.RVector3(curve[-1])
#d[2] = 0.0
d.normalise()
curve = np.append(curve,
[curve[-1] - np.array(d*(max(t)-max(tCurve)))[0:curve.shape[1]]],
axis=0)
tCurve = np.append(tCurve, max(t))
if isinstance(curve, pg.R3Vector) or isinstance(curve, pg.stdVectorRVector3):
xC = pg.x(curve)
yC = pg.y(curve)
zC = pg.z(curve)
else:
if curve.shape[1] == 2:
xC = curve[:, 0]
zC = curve[:, 1]
dim = 2
else:
xC = curve[:, 0]
yC = curve[:, 1]
zC = curve[:, 2]
if len(kwargs.keys()) > 0:
#interpolate more curve points to get a smooth line
dTi = min(pg.utils.dist(pg.utils.diff(curve))) / 10.
ti = np.arange(min(tCurve), max(tCurve)+dTi, dTi)
xC = pg.interpolate(ti, tCurve, xC, **kwargs)
zC = pg.interpolate(ti, tCurve, zC, **kwargs)
if dim == 3:
yC = pg.interpolate(ti, tCurve, yC, **kwargs)
tCurve = ti
xt = interpolate(t, tCurve, xC)
zt = interpolate(t, tCurve, zC)
if dim == 2:
return np.vstack([xt, zt]).T
yt = interpolate(t, tCurve, yC)
return np.vstack([xt, yt, zt]).T
def createElevationGrid(mode,rbfmode=True,source=None,gridCount=20,zfactor=20,bound=10**5,matplot=False):
modeColor={
'linear' : ( 1.0, 0.3, 0.0),
'thin_plate' : (0.0, 1.0, 0.0),
'cubic' : (0.0, 1.0, 1.0),
'inverse' : (1.0, 1.0, 0.0),
'multiquadric' : (1.0, .0, 1.0),
'gaussian' : (1.0, 1.0, 1.0),
'quintic' :(0.5,1.0, 0.0)
}
print ("Source",source,"mode",mode)
if source<>None:
if hasattr(source,"Shape"):
# part object
pts=[v.Point for v in source.Shape.Vertexes]
p=Points.Points(pts)
Points.show(p)
pob=App.ActiveDocument.ActiveObject
pob.ViewObject.PointSize = 10.00
pob.ViewObject.ShapeColor=(1.0,0.0,0.0)
elif hasattr(source,"Points"):
# point cloud
pts=source.Points.Points
elif source.__class__.__name__ == 'DocumentObjectGroup':
hls=App.ActiveDocument.hoehenlinien
apts=[]
for l in hls.OutList:
pts=[v.Point for v in l.Shape.Vertexes]
apts += pts
pts=apts
else:
raise Exception("don't know to get points")
x=[v[1] for v in pts]
y=[v[0] for v in pts]
z=[0.01*v[2] for v in pts]
# staerker
z=[zfactor*v[2] for v in pts]
px= coordLists2points(x,y,z)
Points.show(Points.Points(px))
else:
# testdata
x,y,z= text2coordList(datatext)
p= coordLists2points(x,y,z)
x=np.array(x)
y=np.array(y)
z=np.array(z)
gridsize=gridCount
rbf,xi,yi,zi1 = interpolate(x,y,z, gridsize,mode,rbfmode)
# hilfsebene
xe=[100,-100,100,-100]
ye=[100,100,-100,-100]
ze=[20,10,20,5]
rbf2,xi2,yi2,zi2 = interpolate(xe,ye,ze, gridsize,mode,rbfmode,zi1.shape)
#print zi1.shape
#print zi2.shape
#zi=zi1-zi2
zi=zi1
try: color=modeColor[mode]
except: color=(1.0,0.0,0.0)
xmin=np.min(x)
ymin=np.min(y)
showFace(rbf,rbf2,x,y,gridsize,color,bound)
App.ActiveDocument.ActiveObject.Label=mode + " ZFaktor " + str(zfactor) + " #"
rc=App.ActiveDocument.ActiveObject
if matplot: showHeightMap(x,y,z,zi)
return rc
# interpolation for image
gridsize=400
rbf,xi,yi,zi = interpolate(x,y,z, gridsize,mode,rbfmode)
rbf2,xi2,yi2,zi2 = interpolate(xe,ye,ze, gridsize,mode,rbfmode,zi.shape)
return [rbf,rbf2,x,y,z,zi,zi2]
from scipy.interpolate import interp1d
self.intp = [interp1d(np.linspace(0, Ls, len(r)), r) for r in cqt]
def __call__(self,x):
try:
len(x)
except:
return np.array([i(x) for i in self.intp])
else:
return np.array([[i(xi) for i in self.intp] for xi in x])
real = 1
Ls = 8
c = np.random.randint(0, 255, (10,4)).astype(float)
x = np.linspace(0, Ls, 32)
hf = -1 if real else len(c)/2
grid = interpolate(imap(np.abs, c[2:hf]), Ls)(x)
# display grid
img = np.log(np.flipud(grid.T))
fig = plt.figure()
plt.imshow(img, cmap=plt.cm.gray,
aspect=float(grid.shape[0]) / grid.shape[1] * 0.5,
interpolation='nearest')
plt.show()
from scipy import interpolate
x = np.arange(0, 10)
y = np.exp(-x/3.0)
f = interpolate.interp1d(x, y)
upvpb = ppcompute.mean(up*vp ,axis=0) ; etape("upvpb" ,time0) ; del up ; del vp
print upvpb.shape
upvpbc = ppcompute.mean(upvpb ,axis=2) ; etape("upvpbc",time0) ; del upvpb
### stationary: negligible
#us = pp(file=fileAP,var="u" ,compute="pert_x").getf() ; etape("us",time0)
#vs = pp(file=fileAP,var="v" ,compute="pert_x").getf() ; etape("vs",time0)
#us_b = ppcompute.mean(us ,axis=0) ; etape("usb" ,time0) ; del us
#vs_b = ppcompute.mean(vs ,axis=0) ; etape("vsb" ,time0) ; del vs
#usvsbc = ppcompute.mean(us_b,axis=2)*ppcompute.mean(vs_b,axis=2) ; etape("usvsbc",time0)
#usvsbc = interpolate(targetp1d,press,usvsbc) ; etape("usvsbc",time0)
####################################################
print "... interpolating !"
ubc = interpolate(targetp1d,press,ubc) ; etape("ubc" ,time0) ; addvar(outfile,nam4,'ubc',ubc)
vbc = interpolate(targetp1d,press,vbc) ; etape("vbc" ,time0) ; addvar(outfile,nam4,'vbc',vbc)
#tbc = interpolate(targetp1d,press,tbc) ; etape("tbc" ,time0)
upvpbc = interpolate(targetp1d,press,upvpbc) ; etape("upvpbc",time0)
dudt = interpolate(targetp1d,press,dudt) ; etape("dudt" ,time0) ; addvar(outfile,nam4,'dudt',dudt)
####################################################
nz,nlat = ubc.shape
nlon = 1
lat2d = np.tile(ydim,(nz,1))
acosphi2d = myp.acosphi(lat=lat2d)
cosphi2d = acosphi2d / myp.a
latrad,lat2drad = ydim*np.pi/180.,lat2d*np.pi/180.
beta = myp.beta(lat=lat2d)
f = myp.fcoriolis(lat=lat2d)
print f
def interpolate(x,y,z,xi,yi,type):
X,Y = meshgrid(x,y)
outgrid = interp2d( X,Y,z,kind=type)
zi=outgrid(xi,yi)
return zi
# digitizing the camber factor Kc from ESDU 00027
x_kc = [ 0,0.1,0.2,0.3,0.4,0.5,0.6,0.65,0.7,0.75]
y_kc = [0,0.5,1,1.5,2,2.5,3,3.5,4]
readfile('Kc_z.txt',z_kc)
c=0.7
d=3
Kc= interpolate(x_kc,y_kc,z_kc,c,d,'linear')
# print 'Kc =',Kc
# digitizing the mach number factor Km from ESDU 00027
if M>=0.5 and tm_by_c>=0.08:
x_Km_35_1 = [ 0.5,0.6,0.65,0.7,0.75]
y_Km_35_1 = [0.08,0.1,0.12,0.14,0.16,0.18,0.2]
readfile('Km_35_1.txt',Km_35_1)
Km_35 = interpolate( x_Km_35_1,y_Km_35_1, Km_35_1, M , tm_by_c,'linear')
#print Km_35
if M>=0.5 and tm_by_c<0.08:
x_Km_35_2 = [ 0.02,0.04,0.06,0.08]
y_Km_35_2 = [0.5,0.6,0.65,0.7,0.75]
readfile('Km_35_2.txt',Km_35_2)
bs.interpolate(bsp3)
bss=bs.toShape()
if 0:
prof=FreeCAD.getDocument("Unnamed").addObject("Part::Feature","Length Profile")
prof.Shape=bss
lls2=np.array(lls).swapaxes(0,1)
(y,x,z)=lls2
mode="linear"
gridsize=5
if 0:
rbf,xi,yi,zi1 = interpolate(x,y,z, gridsize,mode)
showHeightMap(x,y,z,zi1)
import random
lan=50
ll=[[l[0],l[1]] for l in lls if l[2]<lan+1 and l[2]>=lan]
'''
from scipy.spatial import Voronoi, voronoi_plot_2d
vor = Voronoi(ll)
import matplotlib.pyplot as plt
voronoi_plot_2d(vor)
def powspec_initialise(cosm):
if choose():
z = raw_input("Enter z value of produced spectrum:")
ident = raw_input("Enter identification number:")
k,P = import_powerspectrum(ident,z)
return interpolate(k,P)
def run(): x, values, header = extract(IN_FILE) newX = np.linspace(0, 1, NUM_ROWS) newValues = interpolate(x, newX, values) output(newX, newValues, header)
def elemchi2(spec,specerr,
elem,elem_linspace=(-0.5,0.5,11),tophat=False,
fparam=None,
teff=4750.,logg=2.5,metals=0.,am=0.,nm=0.,cm=0.,vm=None,
lib='GK',pca=True,sixd=True,dr=None,
offile=None,
inter=3,f_format=1,f_access=None,
verbose=False):
"""
NAME:
elemchi2
PURPOSE:
Calculate the chi^2 for a given element
INPUT:
Either:
(1) location ID - single or list/array of location IDs
APOGEE ID - single or list/array of APOGEE IDs; loads aspcapStar
(2) spec - spectrum: can be (nwave) or (nspec,nwave)
specerr - spectrum errors: can be (nwave) or (nspec,nwave)
elem - element to consider (e.g., 'Al')
elem_linspace= ((-0.5,0.5,11)) numpy.linspace range of abundance, relative to the relevant value in fparam / metals,am,nm,cm
tophat= (False) if True, don't use the value of weights, just use them to define windows that have weight equal to one
Input parameters (can be 1D arrays)
Either:
(1) fparam= (None) output of ferre.fit
(2) teff= (4750.) Effective temperature (K)
logg= (2.5) log10 surface gravity / cm s^-2
metals= (0.) overall metallicity
am= (0.) [alpha/M]
nm= (0.) [N/M]
cm= (0.) [C/M]
vm= if using the 7D library, also specify the microturbulence
Library options:
lib= ('GK') spectral library
pca= (True) if True, use a PCA compressed library
sixd= (True) if True, use the 6D library (w/o vm)
dr= data release
FERRE options:
inter= (3) order of the interpolation
f_format= (1) file format (0=ascii, 1=unf)
f_access= (None) 0: load whole library, 1: use direct access (for small numbers of interpolations), None: automatically determine a good value (currently, 1)
verbose= (False) if True, run FERRE in verbose mode
OUTPUT:
chi^2
HISTORY:
2015-03-12 - Written - Bovy (IAS)
"""
# Parse fparam
if not fparam is None:
teff= fparam[:,paramIndx('TEFF')]
logg= fparam[:,paramIndx('LOGG')]
metals= fparam[:,paramIndx('METALS')]
am= fparam[:,paramIndx('ALPHA')]
nm= fparam[:,paramIndx('N')]
cm= fparam[:,paramIndx('C')]
if sixd:
vm= None
else:
vm= fparam[:,paramIndx('LOG10VDOP')]
# parse spec, specerr input
nspec= len(teff)
if len(spec.shape) == 1:
spec= numpy.reshape(spec,(1,spec.shape[0]))
specerr= numpy.reshape(specerr,(1,specerr.shape[0]))
# Read the weights
if tophat:
weights= apwindow.tophat(elem,apStarWavegrid=False,dr=dr)
else:
weights= apwindow.read(elem,apStarWavegrid=False,dr=dr)
weights/= numpy.sum(weights)
# Decide which parameter to vary
nvelem= elem_linspace[2]
var_elem= numpy.tile(numpy.linspace(*elem_linspace),(nspec,1))
if elem.lower() == 'c':
cm= var_elem+numpy.tile(cm,(nvelem,1)).T
elif elem.lower() == 'n':
nm= var_elem+numpy.tile(nm,(nvelem,1)).T
elif elem.lower() in ['o','mg','s','si','ca','ti']:
am= var_elem+numpy.tile(am,(nvelem,1)).T
else:
metals= var_elem+numpy.tile(metals,(nvelem,1)).T
# Upgrade dimensionality of other parameters for interpolate input
teff= numpy.tile(teff,(nvelem,1)).T
logg= numpy.tile(logg,(nvelem,1)).T
if not sixd:
vm= numpy.tile(vm,(nvelem,1)).T.flatten()
if not elem.lower() == 'c':
cm= numpy.tile(cm,(nvelem,1)).T
if not elem.lower() == 'n':
nm= numpy.tile(nm,(nvelem,1)).T
if not elem.lower() in ['o','mg','s','si','ca','ti']:
am= numpy.tile(am,(nvelem,1)).T
if elem.lower() in ['c','n','o','mg','s','si','ca','ti']:
metals= numpy.tile(metals,(nvelem,1)).T
# Get interpolated spectra, [nspec,nwave]
ispec= interpolate(teff.flatten(),logg.flatten(),metals.flatten(),
am.flatten(),nm.flatten(),cm.flatten(),vm=vm,
lib=lib,pca=pca,sixd=sixd,dr=dr,
inter=inter,f_format=f_format,f_access=f_access,
verbose=verbose,apStarWavegrid=False)
dspec= numpy.tile(spec,(1,nvelem)).reshape((nspec*nvelem,spec.shape[1]))
dspecerr= numpy.tile(specerr,
(1,nvelem)).reshape((nspec*nvelem,spec.shape[1]))
tchi2= _chi2(ispec,dspec,dspecerr,numpy.tile(weights,(nspec*nvelem,1)))
return numpy.reshape(tchi2,(nspec,nvelem))
