def get_envelops(x, t=None):
""" Find the upper and lower envelopes of the array `x`.
"""
if t is None:
t = np.arange(x.shape[0])
maxima = argrelmax(x)[0]
minima = argrelmin(x)[0]
# consider the start and end to be extrema
ext_maxima = np.zeros((maxima.shape[0] + 2,), dtype=int)
ext_maxima[1:-1] = maxima
ext_maxima[0] = 0
ext_maxima[-1] = t.shape[0] - 1
ext_minima = np.zeros((minima.shape[0] + 2,), dtype=int)
ext_minima[1:-1] = minima
ext_minima[0] = 0
ext_minima[-1] = t.shape[0] - 1
tck = interpolate.splrep(t[ext_maxima], x[ext_maxima])
upper = interpolate.splev(t, tck)
tck = interpolate.splrep(t[ext_minima], x[ext_minima])
lower = interpolate.splev(t, tck)
return upper, lower
def interpolate_1km_geolocation(lons_40km, lats_40km):
"""Interpolate AVHRR 40km navigation to 1km.
This code was extracted from the python-geotiepoints package from the PyTroll group. To avoid adding another
dependency to this package this simple case from the geotiepoints was copied.
"""
cols40km = numpy.arange(24, 2048, 40)
cols1km = numpy.arange(2048)
lines = lons_40km.shape[0]
# row_indices = rows40km = numpy.arange(lines)
rows1km = numpy.arange(lines)
lons_rad = numpy.radians(lons_40km)
lats_rad = numpy.radians(lats_40km)
x__ = EARTH_RADIUS * numpy.cos(lats_rad) * numpy.cos(lons_rad)
y__ = EARTH_RADIUS * numpy.cos(lats_rad) * numpy.sin(lons_rad)
z__ = EARTH_RADIUS * numpy.sin(lats_rad)
along_track_order = 1
cross_track_order = 3
lines = len(rows1km)
newx = numpy.empty((len(rows1km), len(cols1km)), x__.dtype)
newy = numpy.empty((len(rows1km), len(cols1km)), y__.dtype)
newz = numpy.empty((len(rows1km), len(cols1km)), z__.dtype)
for cnt in range(lines):
tck = splrep(cols40km, x__[cnt, :], k=cross_track_order, s=0)
newx[cnt, :] = splev(cols1km, tck, der=0)
tck = splrep(cols40km, y__[cnt, :], k=cross_track_order, s=0)
newy[cnt, :] = splev(cols1km, tck, der=0)
tck = splrep(cols40km, z__[cnt, :], k=cross_track_order, s=0)
newz[cnt, :] = splev(cols1km, tck, der=0)
lons_1km = get_lons_from_cartesian(newx, newy)
lats_1km = get_lats_from_cartesian(newx, newy, newz)
return lons_1km, lats_1km
def _genJuddVos(self):
'''
'''
try:
from scipy import interpolate as interp
except ImportError:
raise ImportError('Sorry cannot import scipy')
#lights = np.array([700, 546.1, 435.8])
juddVos = np.genfromtxt('data/ciexyzjv.csv', delimiter=',')
spec = juddVos[:, 0]
juddVos = juddVos[:, 1:]
juddVos[:, 0] *= 100. / sum(juddVos[:, 0])
juddVos[:, 1] *= 100. / sum(juddVos[:, 1])
juddVos[:, 2] *= 100. / sum(juddVos[:, 2])
r, g, b = self.TrichromaticEquation(juddVos[:, 0],
juddVos[:, 1],
juddVos[:, 2])
juddVos[:, 0], juddVos[:, 1], juddVos[:, 2] = r, g, b
L_spline = interp.splrep(spec, juddVos[:, 0], s=0)
M_spline = interp.splrep(spec, juddVos[:, 1], s=0)
S_spline = interp.splrep(spec, juddVos[:, 2], s=0)
L_interp = interp.splev(self.spectrum, L_spline, der=0)
M_interp = interp.splev(self.spectrum, M_spline, der=0)
S_interp = interp.splev(self.spectrum, S_spline, der=0)
JVinterp = np.array([L_interp, M_interp, S_interp]).T
return JVinterp
def __startBarionicAccretionRate(self):
np = 1000
deltaz = self._zmax / float(np)
z = [self._zmax - i * deltaz for i in range(np)]
z.append(0)
z = array(z)
fbt2 = array([self.fbstruc(zi) for zi in z])
ascale = array([1.0 / (1.0 + zi) for zi in z])
self._ascale = ascale
tck = spint.splrep(ascale, fbt2)
ab3 = spint.splev(ascale, tck, der=1)
def a5(z, i):
a = 1.0 / (1.0 + z)
a2 = a * a
a3 = -1.0 * ab3[i] * a2
a4 = a3
a5 = self._cosmology.getRobr0() * abs(a4) \
/ self._cosmology.dt_dz(z)
return a5
self._abt2 = array([a5(z[i], i) for i in range(z.size)])
self._tck_ab = spint.splrep(self._ascale, self._abt2)
def __init__(self, A, h, alpha, CL, CD, rho, smoothing=0, k_spline=3): self.A = A self.h = h self.Asp = 2*self.h**2/self.A self.rho = rho # Input lift and drag data self.n = len(alpha) self.alpha = alpha self.CL = CL self.CD = CD self.k_spline = k_spline # -------- Spline interpolation ----------------------------- if len(self.alpha.shape) == 1: self.interpolationMethod = 'spline' self.nrControlParameters = 1 self.CL_spline = interpolate.splrep(self.alpha, self.CL, s=smoothing, k=self.k_spline) self.CD_spline = interpolate.splrep(self.alpha, self.CD, s=smoothing, k=self.k_spline) elif len(self.alpha.shape) == 2: self.interpolationMethod = 'griddata' self.nrControlParameters = 2 self.CL_RbfModel = interpolate.Rbf(self.alpha[:, 0],self.alpha[:, 1], self.CL, smooth=smoothing) self.CD_RbfModel = interpolate.Rbf(self.alpha[:, 0],self.alpha[:, 1], self.CD, smooth=smoothing)
def _interp1d(self):
"""Interpolate in one dimension."""
lines = len(self.hrow_indices)
self.newx = np.empty((len(self.hrow_indices),
len(self.hcol_indices)),
self.x__.dtype)
self.newy = np.empty((len(self.hrow_indices),
len(self.hcol_indices)),
self.y__.dtype)
self.newz = np.empty((len(self.hrow_indices),
len(self.hcol_indices)),
self.z__.dtype)
for cnt in range(lines):
tck = splrep(self.col_indices, self.x__[cnt, :], k=self.ky_, s=0)
self.newx[cnt, :] = splev(self.hcol_indices, tck, der=0)
tck = splrep(self.col_indices, self.y__[cnt, :], k=self.ky_, s=0)
self.newy[cnt, :] = splev(self.hcol_indices, tck, der=0)
tck = splrep(self.col_indices, self.z__[cnt, :], k=self.ky_, s=0)
self.newz[cnt, :] = splev(self.hcol_indices, tck, der=0)
def RealParts(self, om):
""" calculate functions on real axis
"""
Func=[]
derivs=[]
for i in range(len(self.pos)):
En = self.pos[i]
(x0, dh0) = swing_make_mesh(300, 1e-2*abs(En), 2*abs(En), 7*abs(En))
wb = array([self.F0(x+En, En) for x in x0])
F0j = array([self.F0(x, En) for x in om])
Frc = kramskron(om, F0j, wb, x0, dh0, En)
spl = interpolate.splrep(om, real(Frc), k=3, s=0.0)
dersr = [interpolate.splev(0.0, spl, der=0),
interpolate.splev(0.0, spl, der=1),
interpolate.splev(0.0, spl, der=2)]
spl = interpolate.splrep(om, imag(Frc), k=3, s=0.0)
dersi = [interpolate.splev(0.0, spl, der=0),
interpolate.splev(0.0, spl, der=1),
interpolate.splev(0.0, spl, der=2)]
Func.append(Frc)
ders = array(dersr + dersi)
derivs.append(array(ders))
return (Func, derivs)
def ladybug_interp_data( data ):
'''Interpolates between each 'new' GPS coordinate. Repeated coordinates are
assumed to be incorrect/inaccurate. This method replaces all repetitions
with interpolated coordinates in place. This method uses cubic spline
interpolation.
'''
for i in reversed(xrange(1,len(data['lon']))):
if data['lon'][i] == data['lon'][i-1]:
data['lon'][i] = 1000.0
data['valid'][i] = False
select = where(data['lon'] < 999)
# SPLINE VERSION
data['alt'] = interpolate.splev(data['seqid'],
interpolate.splrep(data['seqid'][select],
data['alt'][select],
s=0, k=2 ),
der=0)
data['lon'] = interpolate.splev(data['seqid'],
interpolate.splrep(data['seqid'][select],
data['lon'][select],
s=0, k=2 ),
der=0)
data['lat'] = interpolate.splev(data['seqid'],
interpolate.splrep(data['seqid'][select],
data['lat'][select],
s=0, k=2 ),
der=0)
return data
def setGrid(self):
from scipy import interpolate
x0 = numpy.logspace(-3,1,81)
etas = numpy.linspace(0.,2.,21)
qs = numpy.linspace(0.2,1.,17)
grid1 = numpy.empty((x0.size,x0.size,etas.size,qs.size))
grid2 = numpy.empty(grid1.shape)
for i in range(qs.size):
q = qs[i]
q2 = q**2
b = 1-q2
for j in range(etas.size):
eta = etas[j]
g = 0.5*eta-1. # g = -1*gamma
for k in range(x0.size):
x = x0[k]
for l in range(x0.size):
y = x0[l]
qb = ((2*x*y)/b)**g # q_bar
qt = q*(x*y)**0.5/b # q_tilde
sb = 0.5*(x/y - y/x) + s**2*b/(2*x*y)
nu1 = s**2*b/(2*x*y)
nu2 = nu1+ 0.5*b*(x/y + y/(x*q2))
nu = numpy.logspace(nu1,nu2,1001)
mu = nu-sb
t = (1+mu**2)**0.5
f1 = (t-mu)**0.5/t
f2 = (t+mu)**0.5/t
ng = nu**g
I1 = interpolate.splrep(nu,f1*ng)
I2 = interpolate.splrep(nu,f2*ng)
grid1[k,l,i,j] = qt*interpolate.splint(nu1,nu2,I1)
grid2[k,l,i,j] = qt*interpolate.splint(nu1,nu2,I2)
pylab.imshow(grid1[:,:,i,j])
pylab.show()
def interp_data_fixed_num(data_set, num=100):
"""
interpolate data with fixed number of points
"""
interp_data = dict()
for key in data_set:
interp_data[key] = []
for l in data_set[key]:
interp_letter = []
for s in l:
time_len = s.shape[0]
if time_len > 3:
#interpolate each dim, cubic
t = np.linspace(0, 1, time_len)
spl_x = interpolate.splrep(t, s[:, 0])
spl_y = interpolate.splrep(t, s[:, 1])
#resample, 4 times more, vel is also scaled...
t_spl = np.linspace(0, 1, num)
x_interp = interpolate.splev(t_spl, spl_x, der=0)
y_interp = interpolate.splev(t_spl, spl_y, der=0)
# #construct new stroke
data = np.concatenate([x_interp, y_interp])
dt = float(time_len)/num
interp_letter.append(np.concatenate([data, [dt]]))
else:
#direct copy if no sufficient number of points
interp_letter.append(s)
interp_data[key].append(interp_letter)
return interp_data
def expand_traj_dim_with_derivative(data, dt=0.01):
augmented_trajs = []
for traj in data:
time_len = len(traj)
t = np.linspace(0, time_len * dt, time_len)
if time_len > 3:
if len(traj.shape) == 1:
"""
mono-dimension trajectory, row as the entire trajectory...
"""
spl = interpolate.splrep(t, traj)
traj_der = interpolate.splev(t, spl, der=1)
tmp_augmented_traj = np.array([traj, traj_der]).T
else:
"""
multi-dimensional trajectory, row as the state variable...
"""
tmp_traj_der = []
for traj_dof in traj.T:
spl_dof = interpolate.splrep(t, traj_dof)
traj_dof_der = interpolate.splev(t, spl_dof, der=1)
tmp_traj_der.append(traj_dof_der)
tmp_augmented_traj = np.vstack([traj.T, np.array(tmp_traj_der)]).T
augmented_trajs.append(tmp_augmented_traj)
return augmented_trajs
def Interpo(spectra) :
wave_min = 1000
wave_max = 20000
pix = 2
#wavelength = np.linspace(wave_min,wave_max,(wave_max-wave_min)/pix+1) #creates N equally spaced wavelength values
wavelength = np.arange(ceil(wave_min), floor(wave_max), dtype=int, step=pix)
fitted_flux = []
fitted_error = []
new = []
#new = Table()
#new['col0'] = Column(wavelength,name = 'wavelength')
new_spectrum=spectra #declares new spectrum from list
new_wave=new_spectrum[:,0] #wavelengths
new_flux=new_spectrum[:,1] #fluxes
new_error=new_spectrum[:,2] #errors
lower = new_wave[0] # Find the area where interpolation is valid
upper = new_wave[len(new_wave)-1]
lines = np.where((new_wave>lower) & (new_wave<upper)) #creates an array of wavelength values between minimum and maximum wavelengths from new spectrum
indata=inter.splrep(new_wave[lines],new_flux[lines]) #creates b-spline from new spectrum
inerror=inter.splrep(new_wave[lines],new_error[lines]) # doing the same with the errors
fitted_flux=inter.splev(wavelength,indata) #fits b-spline over wavelength range
fitted_error=inter.splev(wavelength,inerror) # doing the same with errors
badlines = np.where((wavelength<lower) | (wavelength>upper))
fitted_flux[badlines] = 0 # set the bad values to ZERO !!!
new = Table([wavelength,fitted_flux],names=('col1','col2')) # put the interpolated data into the new table
#newcol = Column(fitted_flux,name = 'Flux')
#new.add_column(newcol,index = None)
return new
def interp_data(data_set):
"""
interpolate data
"""
interp_data = dict()
for key in data_set:
interp_data[key] = []
for l in data_set[key]:
interp_letter = []
for s in l:
time_len = s.shape[0]
if time_len > 3:
#interpolate each dim, cubic
t = np.linspace(0, 1, time_len)
spl_x = interpolate.splrep(t, s[:, 0])
spl_y = interpolate.splrep(t, s[:, 1])
#resample, 4 times more, vel is also scaled...
t_spl = np.linspace(0, 1, 4 * len(t))
x_interp = interpolate.splev(t_spl, spl_x, der=0)
y_interp = interpolate.splev(t_spl, spl_y, der=0)
# #construct new stroke
interp_letter.append(np.concatenate([[x_interp], [y_interp]], axis=0).transpose())
else:
#direct copy if no sufficient number of points
interp_letter.append(s)
interp_data[key].append(interp_letter)
return interp_data
def calc_spline_sqrt_coefs(self):
"""
Calculate cubic spline coefficients for a set of curves.
INPUT:
None
RETURN:
None
For further usage compute spline coefficients for
rmnc_b(s), zmns_b(s), pmns_b(s).
Divide odd m terms by sqrt(s),
keep even m terms as they are.
Use 3rd order qubic spline.
ATTENTION: For interpolation keep in mind to 're-do' sqrt(s)!
For evaluation/interpolation:
Use splev_sqrt(). This routine calls splev() which is
to be found in from scipy.interpolate.
Make sure that splev is imported from scipy.interpolate.
Call like: ynew = splev_sqrt(xnew,sqrt_tck,der=0)
or for derivs yder = splev_sqrt(xnew,sqrt_tck,der=1).
"""
# as we shall not divide by zero...
eps = 1.e-30
self.x = numpy.where(self.x >= eps, self.x, eps)
# do some checks
if(self.y.shape[0] != self.x.shape[0]):
raise Exception, "".join(["dimensions do not agree for: y[n,m]",
"and x[n]"])
if(self.y.shape[1] != self.ixm.shape[0]):
raise Exception, "".join(["dimensions do not agree for: y[n,m]",
"and ixm[m]"])
self.sqrt_tck=[]
if(len(self.y.shape) == 1):
self.sqrt_tck.append(interpolate.splrep(self.x, self.y, s=0))
else:
sqx = numpy.sqrt(self.x)
n = self.y.shape[1]
for i in range(n):
if(self.ixm[i]%2 == 0):
self.sqrt_tck.append(interpolate.splrep(self.x,
self.y[:,i],
s=0))
else:
self.sqrt_tck.append(interpolate.splrep(self.x,
self.y[:,i]/sqx,
s=0))
self.__kind_computed__ |= self.SQRT_SPLINE
self.importQuantity('sqrt_tck', self.sqrt_tck)
self.importQuantity('__kind_computed__', self.__kind_computed__)
return
def VegaFilterMagnitude(filter,spectrum,redshift):
"""
Determines the Vega magnitude (up to a constant) given an input filter,
SED, and redshift.
"""
from scipy.interpolate import splev,splint,splrep
from scipy.integrate import simps
from math import log10
wave = spectrum[0].copy()
data = spectrum[1].copy()
# Redshift the spectrum and determine the valid range of wavelengths
wave *= (1.+redshift)
data /= (1.+redshift)
wmin,wmax = filter[0][0],filter[0][-1]
cond = (wave>=wmin)&(wave<=wmax)
# Evaluate the filter at the wavelengths of the spectrum
response = splev(wave[cond],filter)
# Determine the total observed flux (without the bandpass correction)
observed = splrep(wave[cond],(response*data[cond]),s=0,k=1)
flux = splint(wmin,wmax,observed)
# Determine the magnitude of Vega through the filter
vwave,vdata = getSED('Vega')
cond = (vwave>=wmin)&(vwave<=wmax)
response = splev(vwave[cond],filter)
vega = splrep(vwave[cond],response*vdata[cond],s=0,k=1)
vegacorr = splint(wmin,wmax,vega)
return -2.5*log10(flux/vegacorr)#+2.5*log10(1.+redshift)
def equilData(krange,back, Nbefore):
zzzOutL=np.array([])
zzOutL=np.array([])
fnlOutL=np.array([])
times=np.array([])
Hin = np.array([])
for ii in range(0,np.size(krange)):
k=krange[ ii]
k1 = k
k2=k
k3=k
for jj in range(0,np.size(back[:,0])):
Hin[jj]=MTeasyPy.H(back[jj,1:])
Nexit = interpolate.splev(k, np.exp(back[:,0])*Hin,interpolate.splrep(back[:,1], back[:,0], s=1e-15),der=0)
Nstart = Nexit - Nbefore
backExitMinus = np.zeros(2*nF)
for i in range (1,2*nF+1):
backExitMinus[i-1] = interpolate.splev(Nstart,interpolate.splrep(back[:,0], back[:,i], s=1e-15),der=0)
start_timeIn = time.time()
# run solver for this triangle
t=np.linspace(Nstart,Nend, 10)
threePt = MTeasyPy.alphaEvolve(t,k1,k2,k3, backExitMinus, pvalue, 1)
zzz= threePt[:,:5]
zzzOutL = np.append(zzzOutL, zzz[-1,4])
zzOutL = np.append(zzOutL, zzz[-1,1])
times = np.append(times, time.time()-start_timeIn)
return (zzOutL, zzzOutL, times)
def calc_spline_conv_coefs(self):
"""
Calculate cubic spline coefficients for a set of curves.
INPUT:
None
RETURN:
None
For evaluation/interpolation:
Make sure that splev is imported from scipy.interpolate.
Call like: ynew = splev(xnew,tck,der=0)
or for derivs yder = splev(xnew,tck,der=1).
"""
# do some checks
if(self.y.shape[0] != self.x.shape[0]):
raise Exception, "".join(["dimensions do not agree for: y[n,m]",
"and x[n]"])
self.tck=[]
if(len(self.y.shape) == 1):
self.tck.append(interpolate.splrep(self.x, self.y, s=0))
else:
n = self.y.shape[1]
for i in range(n):
self.tck.append(interpolate.splrep(self.x, self.y[:,i], s=0))
self.__kind_computed__ |= self.CONV_SPLINE
self.importQuantity('tck', self.tck)
self.importQuantity('__kind_computed__', self.__kind_computed__)
return
def apply_map(self, tau, kind = 'linear'):
"""
Actually use the motor map to calculate the slip speed and the motor
efficiency
Parameters
----------
tau : float
Torque [N-m]
kind : string, optional
The kind of interpolation to do (see scipy.interpolate.interp1d) - deprecated
Returns
-------
eta : float
Efficiency [-]
omega : float
Rotational speed [rad/s]
"""
if not kind == 'linear':
warnings.warn('apply_map does not take parameter "kind" anymore')
eta_interp = interp.splrep(self.tau_coeffs, self.eta_coeffs, k=2, s=0)
eta = interp.splev(tau, eta_interp)
omega_interp = interp.splrep(self.tau_coeffs, self.omega_coeffs, k=2, s=0)
omega = interp.splev(tau, omega_interp)
#Return the values
return eta, omega
def getInitialCurve(im, nbr_points):
""" Select a number of vertices for builing a cubic spline planar
curve and return a set of nbr_points of that curve, with equidistant
parametrization.
"""
im = np.array(im)
plt.gray()
plt.imshow(np.flipud(im), origin='lower')
vertices = np.array(plt.ginput(0, timeout=10))
# I add an extra point to close the curve
# this is for spline interpolation
# I will remove it from the interpolant
vx = vertices[:,0]
vx = np.append(vx, vx[0])
vy = vertices[:,1]
vy = np.append(vy, vy[0])
nbr_vertices = len(vx)
t = np.linspace(0,nbr_vertices,nbr_vertices) #returns an array of numbers from 0 to nbr of clicks+1. Num of samples are also nbr of clicks+1. E.g. 4 clicks: ([0., x.x, x.x, x.x, 5.])
sx = interpolate.splrep(t, vx, s= 0)
sy = interpolate.splrep(t, vy, s= 0)
tnew = np.linspace(0, nbr_vertices, nbr_points+1)
vxnew = interpolate.splev(tnew, sx, der=0)
vynew = interpolate.splev(tnew, sy, der=0)
# I don't want the last point
return vxnew[:-1], vynew[:-1], vertices
def bspline(pts, degree, smoothness):
# cycle check
periodic = False
if pts[0] == pts[-1]:
# pts.pop()
periodic = True
pts = pts[:-1]
if periodic: pts = pts + pts[0 : degree+1]
else: pts = [pts[0]] + pts + [pts[-1],pts[-1]]
pts = array(pts)
n_points = len(pts)
x, y = pts[:,0], pts[:,1]
t = range(len(x))
ipl_t = linspace(1.0, len(pts) - degree, smoothness)
x_tup = si.splrep(t, x, k=degree, per=periodic)
y_tup = si.splrep(t, y, k=degree, per=periodic)
x_list = list(x_tup)
xl = x.tolist()
y_list = list(y_tup)
yl = y.tolist()
if periodic:
x_list[1] = [0.0] + xl + [0.0, 0.0, 0.0, 0.0]
y_list[1] = [0.0] + yl + [0.0, 0.0, 0.0, 0.0]
x_i = si.splev(ipl_t, x_list)
y_i = si.splev(ipl_t, y_list)
return zip(x_i, y_i)
def upsample_to_memmap(x,factor=10):
"""Performs upsampling using splines and returns a memmap. Now works for 1d, 2d and 3d arrays."""
factor = int(round(factor))
if factor<1 or factor>1000000:
raise ValueError("Illegal value for the upsampling-factor")
if len(x.shape) == 1: #1d
#y = np.zeros((factor*x.shape[0]),"d")
spl = splrep(np.arange(x.shape[0]),x)
#f = interp1d(np.arange(x.shape[0]),x)
y,tmp_fn = tmp_memmap(dtype=np.double,shape=(x.shape[0]*factor),mode="w+")
y[:] = splev(np.arange(0,x.shape[0],1.0/factor),spl)
#y[:-factor] = f(np.arange(0,x.shape[0],1.0/factor)[:-factor])
#y[:] = resample(x,x.shape[0]*factor)
#TODO: make kind of interpolation consistent for different dimensionalities
elif len(x.shape) == 2: #1d
y,tmp_fn = tmp_memmap(dtype=np.double,shape=(x.shape[0]*factor,x.shape[1]),mode="w+")
for i in range(x.shape[1]):
spl = splrep(np.arange(x.shape[0]),x[:,i])
y[:,i] = splev(np.arange(0,x.shape[0],1.0/factor),spl)
elif len(x.shape) == 3: #1d
y,tmp_fn = tmp_memmap(dtype=np.double,shape=(x.shape[0]*factor,x.shape[1],x.shape[2]),mode="w+")
for i in range(x.shape[1]):
for j in range(x.shape[2]):
spl = splrep(np.arange(x.shape[0]),x[:,i,j])
y[:,i,j] = splev(np.arange(0,x.shape[0],1.0/factor),spl)
else:
raise ValueError("Only 1d, 2d and 3d arrays are accepted for upsampling up to now.")
return y, tmp_fn
def pgrid(self,tname):
self._hasTeff_ = True
self._hasLogg_ = True
self._hasMet_ = False
grid = Table.read(tname,format='ascii.no_header')
len_teff = len(np.unique(grid['col2']))
len_logg = len(np.unique(grid['col3']))
# Reads Teff
self.gteff = np.zeros(len_teff)
for i,ii in enumerate(np.arange(len_teff)*len_logg):
self.gteff[i] = np.float(os.path.basename(grid['col1'][ii])[2:].split('_')[0])
# Reads logg
self.glogg = np.zeros(len_logg)
for i,ii in enumerate(np.arange(len_logg)):
self.glogg[i] = np.float(os.path.basename(grid['col1'][ii]).split('_')[1].split('.')[0])
# evalute grid interpolation
self._teffc = itrp.splrep(np.arange(len_teff),self.gteff)
self._loggc = itrp.splrep(np.arange(len_logg),self.glogg)
def GetSourceSize(self,kpc=False):
self.z=source_redshifts[self.name]
self.Da = astCalc.da(self.z)
self.scale = self.Da*1e3*np.pi/180./3600.
if len(self.srcs) == 1 or self.name == 'J0837':
self.Re_v = self.Ddic['Source 1 re']*0.05
self.Re_i = self.Re_v.copy()
self.Re_lower = self.Ldic['Source 1 re']*0.05
self.Re_upper = self.Udic['Source 1 re']*0.05
elif len(self.srcs) == 2 and self.name != 'J0837':
print 'test this out...!'
Xgrid = np.logspace(-4,5,1501)
Res = []
for i in range(len(self.imgs)):
#if self.name == 'J1605':
# source =
source = self.fits[i][-3]*self.srcs[0].eval(Xgrid) + self.fits[i][-2]*self.srcs[1].eval(Xgrid)
R = Xgrid.copy()
light = source*2.*np.pi*R
mod = splrep(R,light,t=np.logspace(-3.8,4.8,1301))
intlight = np.zeros(len(R))
for i in range(len(R)):
intlight[i] = splint(0,R[i],mod)
model = splrep(intlight[:-300],R[:-300])
if len(model[1][np.where(np.isnan(model[1])==True)]>0):
print "arrays need to be increasing monotonically! But don't worry about it"
model = splrep(intlight[:-450],R[:-450])
reff = splev(0.5*intlight[-1],model)
Res.append(reff*0.05)
self.Re_v,self.Re_i = Res
if kpc:
return [self.Re_v*self.scale, self.Re_i*self.scale]
return [self.Re_v, self.Re_i]
def qvRealtion(voltage):
global chargeVoltage, chargeQuantity
vPoints = chargeVoltage
qPoints = chargeQuantity
SOCPoints = chargeSOC
qvCurveTck = interpolate.splrep(vPoints, qPoints, s = 0.002)
batteryQuantity = interpolate.splev(voltage, qvCurveTck, der = 0)
SOCVCurveTck = interpolate.splrep(SOCPoints, vPoints,s = 0.002)
batterySOC = interpolate.splev(voltage, SOCVCurveTck, der = 0)
newX = np.arange(vPoints[0], vPoints[-1], 0.1)
newY = interpolate.splev(newX, qvCurveTck, der = 0)
plt.plot(vPoints, qPoints, 'o', newX, newY, '-')
plt.title("V-Q curve")
newSOC = np.arange(SOCPoints[0], SOCPoints[-1], 0.01)
newVoltage = interpolate.splev(newSOC, SOCVCurveTck, der = 0)
plt.plot(SOCPoints, vPoints, 'o', newSOC, newVoltage, '-')
plt.title("V-SOC curve")
plt.show()
return batteryQuantity
def conv2(lam,flu,ac,bc,rot):
lux = 299792.458
WAV = np.array([3530,4860,6260,7670,8350])
"""Determining Limb Darkening Coefficients"""
tck = interpolate.splrep(WAV,ac,k=3,s=0)
A = interpolate.splev(lam,tck,der=0)
tck = interpolate.splrep(WAV,bc,k=3,s=0)
B = interpolate.splev(lam,tck,der=0)
F = flu.copy()
MIN = lam * ( 1. - float(rot) / lux )
MAX = lam * ( 1. + float(rot) / lux )
lar = len(F)
if rot > 0.0:
H = Cfunctions.Conv(lam.astype("double"),flu.astype("double"),F.astype("double"), \
A.astype("double"),B.astype("double"),MIN.astype("double"),MAX.astype("double"),rot,lar)
else:
H = flu
Fnu = np.array(H)
return Fnu
def get_optimal_splines(events, optimise_bin_edges, k=1):
cut_events = {}
cut_energies, ga_cuts, xi_cuts = [], [], []
for elow, ehigh, emid in zip(optimise_bin_edges[:-1],
optimise_bin_edges[1:],
np.sqrt(optimise_bin_edges[:-1] *
optimise_bin_edges[1:])):
for key in events:
cut_events[key] = events[key][
(events[key]["MC_Energy"] > elow) &
(events[key]["MC_Energy"] < ehigh)]
res = optimize.differential_evolution(
cut_and_sensitivity,
bounds=[(.5, 1), (0, 0.5)],
maxiter=1000, popsize=10,
args=(cut_events,
np.array([elow / energy_unit,
ehigh / energy_unit]) * energy_unit,
alpha)
)
if res.success:
cut_energies.append(emid.value)
ga_cuts.append(res.x[0])
xi_cuts.append(res.x[1])
spline_ga = interpolate.splrep(cut_energies, ga_cuts, k=k)
spline_xi = interpolate.splrep(cut_energies, xi_cuts, k=k)
return (spline_ga, ga_cuts), (spline_xi, xi_cuts)
def envelope(min_arr, max_arr, N, periodic=0):
#Cubic Spline by default
order_max = 3
order_min = 3
min_arr = np.asarray(min_arr)
max_arr = np.asarray(max_arr)
if min_arr.shape[1] < 4:
order_min = 1 #Do linear interpolation if not enough points
elif min_arr.shape[1] < 5:
order_min = 2 #Do quad interpolation if not enough points
else:
order_min = 3
if max_arr.shape[1] < 4:
order_max = 1 #Do linear interpolation if not enough points
elif max_arr.shape[1] < 5:
order_max = 2 #Do quad interpolation if not enough points
else:
order_max = 3
# Mirror Method requires per flag = 1
# No extrapolation requires per flag = 0
t = interpolate.splrep(*min_arr, k=order_min, per=periodic)
top = interpolate.splev(np.arange(N), t)
b = interpolate.splrep(*max_arr, k=order_max, per=periodic)
bot = interpolate.splev(np.arange(N), b)
mean = (top + bot)/2
return mean
def Interpo (wave, flux, variance) :
wave_min = 1500
wave_max = 12000
dw = 2
#wavelength = np.linspace(wave_min,wave_max,(wave_max-wave_min)/pix+1)
wavelength = np.arange(math.ceil(wave_min), math.floor(wave_max), dtype=int, step=dw) #creates N equally spaced wavelength values
inter_flux = []
inter_var = []
output = []
lower = wave[0] # Find the area where interpolation is valid
upper = wave[-1]
good_data = np.where((wave >= lower) & (wave <= upper)) #creates an array of wavelength values between minimum and maximum wavelengths from new spectrum
influx = inter.splrep(wave[good_data], flux[good_data]) #creates b-spline from new spectrum
invar = inter.splrep(wave[good_data], variance[good_data]) # doing the same with the errors
inter_flux = inter.splev(wavelength, influx) #fits b-spline over wavelength range
inter_var = inter.splev(wavelength, invar) # doing the same with errors
missing_data = np.where((wavelength < lower) | (wavelength > upper))
inter_flux[missing_data] = float('NaN') # set the bad values to NaN !!!
inter_var[missing_data] = float('NaN')
output = np.array([wavelength, inter_flux, inter_var]) # put the interpolated data into the new table
return output # return new table
def fit_fwhm_enclosed_direct(peak, rad, flux):
# We use splines to interpolate and derivate
spl = splrep(rad, flux)
# First derivative
vald1 = splev(rad, spl, der=1)
splinter = splrep(rad, vald1 - math.pi * peak * rad)
roots = sproot(splinter)
nroots = len(roots)
if peak < 0:
msg = "The method doesn't converge, peak is negative"
fwhm = -99
else:
if nroots == 0:
msg = "The method doesn't converge, no roots"
fwhm = -99
elif nroots == 1:
r12 = roots[0]
fwhm = 2 * r12
msg = "The method converges, one root"
else:
msg = "The method doesn't converge, multiple roots"
r12 = roots[0]
fwhm = 2 * r12
return peak, fwhm, msg
def redshiftfunctions(self):
D=self.D
zbins=self.zbins
z2bins=self.z2bins
Dabins=zbins*0.0
Dmodbins=zbins*0.0
Da2bins=numpy.zeros((z2bins.size,z2bins.size))
volumebins=zbins*0.0
for i in range(zbins.size):
Dabins[i]=D.Da(zbins[i])
Dmodbins[i]=D.distance_modulus(zbins[i])
volumebins[i]=D.volume(zbins[i])
for i in range(z2bins.size):
for j in range(z2bins.size):
if j>i:
Da2bins[i,j]=D.Da(z2bins[i],z2bins[j])
self.Da_spline=interpolate.splrep(zbins,Dabins)
self.Dmod_spline=interpolate.splrep(zbins,Dmodbins)
self.volume_spline=interpolate.splrep(zbins,volumebins)
z2d=iT.coords((z2bins.size,z2bins.size))*self.dz2
self.Da_bispline=interpolate.RectBivariateSpline(z2bins,z2bins,Da2bins)
#pickle the splines
splinedump=open("redshiftsplines.pkl","wb")
cPickle.dump([self.Da_spline,self.Dmod_spline,self.volume_spline,self.Da_bispline],splinedump,2)
def _interp_cubic_spline(rri, time, fs):
time_rri_interp = _create_interp_time(time, fs)
tck = interpolate.splrep(time, rri, s=0)
rri_interp = interpolate.splev(time_rri_interp, tck, der=0)
return rri_interp
def interpolate(*args, **kwargs):
r"""Interpolation convinience function.
Convenience function to interpolate different kind of data.
Currently supported interpolation schemes are:
* Interpolate mesh based data from one mesh to another
(syntactic sugar for the core based interpolate (see below))
Parameters:
args: :gimliapi:`GIMLI::Mesh`, :gimliapi:`GIMLI::Mesh`, iterable
`outData = interpolate(outMesh, inMesh, vals)`
Interpolate values based on inMesh to outMesh.
Values can be of length inMesh.cellCount() interpolated to
outMesh.cellCenters() or inMesh.nodeCount() which are interpolated tp
outMesh.positions().
Returns:
Interpolated values.
* Mesh based values to arbitrary points, based on finite element
interpolation (from gimli core).
Parameters:
args: :gimliapi:`GIMLI::Mesh`, ...
Arguments forwarded to :gimliapi:`GIMLI::interpolate`
kwargs:
Arguments forwarded to :gimliapi:`GIMLI::interpolate`
`interpolate(srcMesh, destMesh)`
All data from inMesh are interpolated to outMesh
Returns:
Interpolated values
* Interpolate along curve.
Forwarded to :py:mod:`pygimli.meshtools.interpolateAlongCurve`
Parameters:
args: curve, t
kwargs:
Arguments forwarded to
:py:mod:`pygimli.meshtools.interpolateAlongCurve`
* 1D point set :math:`u(x)` for ascending :math:`x`.
Find interpolation function :math:`I = u(x)` and
returns :math:`u_{\text{i}} = I(x_{\text{i}})`
(interpolation methods are [**linear** via matplotlib,
cubic **spline** via scipy, fit with **harmonic** functions' via pygimli])
Note, for 'linear' and 'spline' the interpolate contains all original
coordinates while 'harmonic' returns an approximate best fit.
The amount of harmonic coefficients can be specfied with the 'nc' keyword.
Parameters:
args: xi, x, u
* :math:`x_{\text{i}}` - target sample points
* :math:`x` - function sample points
* :math:`u` - function values
kwargs:
* method : string
Specify interpolation method 'linear, 'spline', 'harmonic'
* nc : int
Number of harmonic coefficients for the 'harmonic' method.
Returns:
ui: array of length xi
:math:`u_{\text{i}} = I(x_{\text{i}})`, with :math:`I = u(x)`
To use the core functions :gimliapi:`GIMLI::interpolate` start with a
mesh instance as first argument or use the appropriate keyword arguments.
TODO
* 2D parametric to points (method=['linear, 'spline', 'harmonic'])
* 2D/3D point cloud to points/grids ('Delauney', 'linear, 'spline', 'harmonic')
* Mesh to points based on nearest neighbour values (pg.core)
Examples
--------
>>> # no need to import matplotlib. pygimli's show does
>>> import numpy as np
>>> import pygimli as pg
>>> fig, ax = pg.plt.subplots(1, 1, figsize=(10, 5))
>>> u = np.array([1.0, 12.0, 3.0, -4.0, 5.0, 6.0, -1.0])
>>> xu = np.array(range(len(u)))
>>> xi = np.linspace(xu[0], xu[-1], 1000)
>>> _= ax.plot(xu, u, 'o')
>>> _= ax.plot(xi, pg.interpolate(xi, xu, u, method='linear'),
... color='blue', label='linear')
>>> _= ax.plot(xi, pg.interpolate(xi, xu, u, method='spline'),
... color='red', label='spline')
>>> _= ax.plot(xi, pg.interpolate(xi, xu, u, method='harmonic'),
... color='green', label='harmonic')
>>> _= ax.legend()
"""
pgcore = False
if 'srcMesh' in kwargs:
pgcore = True
elif len(args) > 0:
if isinstance(args[0], pg.Mesh):
if len(args) == 2 and isinstance(args[1], pg.Mesh):
return pg.core._pygimli_.interpolate(args[0], args[1],
**kwargs)
if len(args) == 3 and isinstance(args[1], pg.Mesh):
pgcore = False # (outMesh, inMesh, vals)
else:
pgcore = True
if pgcore:
if len(args) == 3: # args: outData = (inMesh, inData, outPos)
if args[1].ndim == 2: # outData = (inMesh, mat, vR3)
outMat = pg.Matrix()
pg.core._pygimli_.interpolate(args[0],
inMat=np.array(args[1]),
destPos=args[2],
outMat=outMat,
**kwargs)
return np.array(outMat)
if len(args) == 4: # args: (inMesh, inData, outPos, outData)
if args[1].ndim == 1 and args[2].ndim == 1 and args[3].ndim == 1:
return pg.core._pygimli_.interpolate(args[0],
inVec=args[1],
x=args[2],
y=args[3],
**kwargs)
if isinstance(args[1], pg.RMatrix) and \
isinstance(args[3], pg.RMatrix):
return pg.core._pygimli_.interpolate(args[0],
inMat=args[1],
destPos=args[2],
outMat=args[3],
**kwargs)
if isinstance(args[1], pg.RVector) and \
isinstance(args[3], pg.RVector):
return pg.core._pygimli_.interpolate(args[0],
inVec=args[1],
destPos=args[2],
outVec=args[3],
**kwargs)
if len(args) == 5:
if args[1].ndim == 1 and args[2].ndim == 1 and \
args[3].ndim == 1 and args[4].ndim == 1:
return pg.core._pygimli_.interpolate(args[0],
inVec=args[1],
x=args[2],
y=args[3],
z=args[4],
**kwargs)
return pg.core._pygimli_.interpolate(*args, **kwargs)
# end if pg.core:
if len(args) == 3:
if isinstance(args[0], pg.Mesh): # args: (outMesh, inMesh, data)
outMesh = args[0]
inMesh = args[1]
data = args[2]
if isinstance(data, pg.R3Vector) or isinstance(
data, pg.stdVectorRVector3):
x = pg.interpolate(outMesh, inMesh, pg.x(data))
y = pg.interpolate(outMesh, inMesh, pg.y(data))
z = pg.interpolate(outMesh, inMesh, pg.z(data))
return np.vstack([x, y, z]).T
if isinstance(data, np.ndarray):
if data.ndim == 2 and data.shape[1] == 3:
x = pg.interpolate(outMesh, inMesh, data[:, 0])
y = pg.interpolate(outMesh, inMesh, data[:, 1])
z = pg.interpolate(outMesh, inMesh, data[:, 2])
return np.vstack([x, y, z]).T
if len(data) == inMesh.cellCount():
return pg.interpolate(srcMesh=inMesh,
inVec=data,
destPos=outMesh.cellCenters())
elif len(data) == inMesh.nodeCount():
return pg.interpolate(srcMesh=inMesh,
inVec=data,
destPos=outMesh.positions())
else:
print(inMesh)
print(outMesh)
raise Exception("Don't know how to interpolate data of size",
str(len(data)))
print("data: ", data)
raise Exception("Cannot interpret data: ", str(len(data)))
else: #args: xi, x, u
xi = args[0]
x = args[1]
u = args[2]
method = kwargs.pop('method', 'linear')
if 'linear' in method:
return np.interp(xi, x, u)
if 'harmonic' in method:
coeff = kwargs.pop('nc', int(np.ceil(np.sqrt(len(x)))))
from pygimli.frameworks import harmfitNative
return harmfitNative(u, x=x, nc=coeff, xc=xi, err=None)[0]
if 'spline' in method:
if pg.optImport("scipy",
requiredFor="use interpolate splines."):
from scipy import interpolate
tck = interpolate.splrep(x, u, s=0)
return interpolate.splev(xi, tck, der=0)
else:
return xi * 0.
if len(args) == 2: # args curve, t
curve = args[0]
t = args[1]
return interpolateAlongCurve(curve, t, **kwargs)
def f(x, x_points, y_points):
tck = interpolate.splrep(x_points, y_points)
return interpolate.splev(x, tck)
def main():
# Parameters
doproj = True # Model projected statistics (or angular statistics)
if (doproj):
opt = 1 # 1) Delta Sigma 2) w_p 3) xi
rmin = 0.5 # Minimum projected separation of model [Mpc/h]
rmax = 50. # Maximum projected separation of model [Mpc/h]
nrbin = 10 # Number of bins of model
rlinlog = 2 # Space bins as 1) linear or 2) logarithmic
pimax = 60. # Limit of integral over Pi [Mpc/h]
else:
opt = 1 # 1) xi_+ 2) xi_- 3) gamma_t 4) w
thmin = 0.03 # Minimum angular separation of model [degrees]
thmax = 3. # Maximum angular separation of model [degrees]
nthbin = 20 # Number of bins of model
thlinlog = 2 # Space bins as 1) linear or 2) logarithmic
lmin = 1. # Minimum multipole to pre-compute
lmax = 1.e+5 # Maximum multipole to pre-compute
nl = 500 # Number of multipole bins to pre-compute
# Cosmological model
om = 0.286 # Omega_m
h = 0.7 # Hubble parameter
fb = 0.164335664336 # Baryon fraction
sig8 = 0.82 # sigma_8
b = 1. # Galaxy bias
# Files containing the source and lens redshift distributions
pzsourcefile = 'pz_sources_buzzard_zp0pt80_1pt00.dat'
pzlensfile = 'pz_lenses_buzzard_lrg_zs0pt40_0pt60.dat'
# File containing the model power spectrum
pkcambfile,npcamb,nkcamb = 'pkcambhalofit_zrange_buzzard.dat',21,922
klinlog,kminmod,kmaxmod,nkmod = 2,1.e-4,0.999e+4,800
# Pre-compute model as a function of r
rminmod,rmaxmod,nrmod = 1.e-4,1.e+3,70
# Limits of integral over k
kminint,kmaxint = 1.e-4,0.999e+4
# astropy cosmology
cosmo = FlatLambdaCDM(H0=100.,Om0=om)
# Read in redshift distributions
zsourcearr,pzsourcearr,zminsource,zmaxsource = readnz(pzsourcefile)
zlensarr,pzlensarr,zminlens,zmaxlens = readnz(pzlensfile)
tcksource = splrep(zsourcearr,pzsourcearr)
tcklens = splrep(zlensarr,pzlensarr)
# Read in power spectra
kmod,zmod,pkzmod = readpkcamb(pkcambfile,npcamb,nkcamb,om,h,fb,sig8,klinlog,kminmod,kmaxmod,nkmod)
# Determine radial functions
zsourcearr,fsourcearr = getfsource(0.,zmaxsource,zminsource,zmaxsource,tcksource,cosmo)
zlensarr,flensarr = getflens(zminlens,zmaxlens,tcklens,cosmo)
# Compute projected lensing correlation functions
if (doproj):
z = 0.5*(zminlens+zmaxlens)
pkmod = intpkzmod(z,zmod,pkzmod)
# Generate lensing function
rbin,lensprojmod = getlensprojmod(opt,rmin,rmax,nrbin,rlinlog,pimax,rminmod,rmaxmod,nrmod,kminint,kmaxint,kmod,pkmod,om)
# Compute angular lensing correlation functions
else:
# Determine angular power spectra
larr,clshapearr = getclshapearr(opt,lmin,lmax,nl,zminlens,zmaxlens,zlensarr,flensarr,zminsource,zmaxsource,zsourcearr,fsourcearr,kmod,zmod,pkzmod,om,b,cosmo)
# Generate lensing function
thdeg,lensshapemod = getlensangmod(opt,thmin,thmax,nthbin,thlinlog,lmin,lmax,larr,clshapearr)
return
def _interpolate(self, spline, spline_size):
spline = np.append(spline, spline[0])
x = np.linspace(0, 1, len(spline))
tck = splrep(x, spline, per=True)
x2 = np.linspace(0, 1, spline_size)
return splev(x2, tck)[:-1]
df.drop_duplicates(inplace=True)
df['y_invert'] = df['y'].mean() - df.y
# df.plot('x','y_invert')
base = peakutils.baseline(df.y_invert, 2)
indexes = peakutils.indexes(df.y_invert - base,
thres=0.00001,
min_dist=200)
# print(indexes)
# pplot(df.x,df.y_invert, indexes)
for i in indexes:
if i[(i < 100) & (i > 5)]:
peak_x = i
x2, y2 = df.x, df.y_invert
skewness = stats.skew(y2)
tck = interpolate.splrep(
x2, y2, s=.00000001
) # s =m-sqrt(2m) where m= #datapts and s is smoothness factor
x_ = np.arange(np.min(x2), np.max(x2), 0.003)
y_ = interpolate.splev(x_, tck, der=0)
HM = (np.max(y_) - np.min(y_)) / 2
w = splrep(x_, y_ - HM, k=3)
# print(sproot(w_j))
try:
if len(sproot(w)) % 2 == 0:
r1, r2 = sproot(w)
# print(r1 , r2)
FWHM = np.abs(r1 - r2)
# half_width.append(FWHM)
center_wavelength = r1 + FWHM / 2
# peak_center.append(center_wavelength)
def interpol(self, emin, emax, rom, broaden, dest_dir, sp=False):
"""
This performs the interpolation of points on the real axis.
"""
print("\nInterpolating points on real axis...")
headerline = 2
om, Sig = Fileio.Read_complex_multilines("./ac/Sig.out", headerline)
s_oo = None
Vdc = None
# The exec() function doesn't work properly on Python3 so I had to use a workaround:
fi = open("./ac/Sig.out", "r")
line1 = fi.readline()
s_oo = re.findall(r"\s*([0-9.+-]*)", line1)
while "" in s_oo:
s_oo.remove("")
line2 = fi.readline()
Vdc = re.findall(r"\s*([0-9.+-]*)", line2)
while "" in Vdc:
Vdc.remove("")
# exec(ar[0])
# m=re.search('#(.*)',line)
# exec(m.group(1).strip())
# s_oo_Vdc=np.array(s_oo)-array(Vdc)
fi.close()
s_oo_Vdc = np.array((np.array(s_oo)).astype(np.float)) - np.array(
(np.array(Vdc)).astype(np.float)
)
ommesh = np.linspace(emin, emax, rom)
# non spin polarized case
if sp == False:
Sig_tot = np.zeros((len(Sig), rom), dtype=complex)
for i in range(len(Sig)):
SigSpline = interpolate.splrep(om, Sig[i].real, k=1, s=0)
Sig_tot[i, :] += interpolate.splev(ommesh, SigSpline)
SigSpline = interpolate.splrep(om, Sig[i].imag, k=1, s=0)
Sig_tot[i, :] += 1j * interpolate.splev(ommesh, SigSpline)
header1 = "# nom,ncor_orb= " + str(len(ommesh)) + " " + str(len(Sig_tot))
# header2='# T= %18.15f'%(1.0/pC['beta'][0])#+str(self.T)
header2 = "# T= %18.15f" % (broaden) # +str(self.T)
header3 = "# s_oo-Vdc= "
for i in range(len(s_oo_Vdc)):
header3 += "%18.15f " % (s_oo_Vdc[i])
header4 = "# s_oo= " + str(s_oo)
header5 = "# Vdc= " + str(Vdc)
if dest_dir == "dos":
Fileio.Print_complex_multilines(
Sig_tot,
ommesh,
"./dos/sig.inp_real",
[header1, header2, header3, header4, header5],
)
# create sig.inp_real
if dest_dir == "bands":
Fileio.Print_complex_multilines(
Sig_tot,
ommesh,
"./bands/sig.inp_real",
[header1, header2, header3, header4, header5],
)
# Spin polarized calculation
if sp:
Sig_tot = np.zeros((int(len(Sig) / 2), rom), dtype=complex)
Sig_tot_dn = np.zeros((int(len(Sig) / 2), rom), dtype=complex)
for i in range(int(len(Sig) / 2)):
# spin
SigSpline = interpolate.splrep(om, Sig[i].real, k=1, s=0)
Sig_tot[i, :] += interpolate.splev(ommesh, SigSpline)
SigSpline = interpolate.splrep(om, Sig[i].imag, k=1, s=0)
Sig_tot[i, :] += 1j * interpolate.splev(ommesh, SigSpline)
# spin down
SigSpline = interpolate.splrep(
om, Sig[i + int(len(Sig) / 2)].real, k=1, s=0
)
Sig_tot_dn[i, :] += interpolate.splev(ommesh, SigSpline)
SigSpline = interpolate.splrep(
om, Sig[i + int(len(Sig) / 2)].imag, k=1, s=0
)
Sig_tot_dn[i, :] += 1j * interpolate.splev(ommesh, SigSpline)
header1 = "# nom,ncor_orb= " + str(len(ommesh)) + " " + str(len(Sig_tot))
header2 = "# T= %18.15f" % (broaden)
header3 = "# s_oo-Vdc= "
header3_dn = "# s_oo-Vdc= "
for i in range(int(len(s_oo_Vdc) / 2)):
header3 += "%18.15f " % (s_oo_Vdc[i])
header3_dn += "%18.15f " % (s_oo_Vdc[i + int(len(s_oo_Vdc) / 2)])
header4 = "# s_oo= " + str(s_oo[0 : int(len(s_oo) / 2)])
header4_dn = "# s_oo= " + str(s_oo[int(len(s_oo) / 2) :])
header5 = "# Vdc= " + str(Vdc[0 : int(len(Vdc) / 2)])
header5_dn = "# Vdc= " + str(Vdc[int(len(Vdc) / 2) :])
if dest_dir == "dos":
Fileio.Print_complex_multilines(
Sig_tot,
ommesh,
"./dos/sig.inp_real",
[header1, header2, header3, header4, header5],
)
Fileio.Print_complex_multilines(
Sig_tot_dn,
ommesh,
"./dos/sig.inp_real_dn",
[header1, header2, header3_dn, header4_dn, header5_dn],
)
# create sig.inp_real
if dest_dir == "bands":
Fileio.Print_complex_multilines(
Sig_tot,
ommesh,
"./bands/sig.inp_real",
[header1, header2, header3, header4, header5],
)
Fileio.Print_complex_multilines(
Sig_tot_dn,
ommesh,
"./bands/sig.inp_real_dn",
[header1, header2, header3_dn, header4_dn, header5_dn],
)
print("Interpolation complete.\n")
ax.legend()
number_of_ticks = 20
ax.set_xlabel('$X$')
ax.set_ylabel('$Y$')
ax.set_zlabel('$frame no $', rotation=0)
ax.zaxis.set_ticks(
np.arange(min(Z),
max(Z) + (max(Z) - min(Z)) / number_of_ticks,
((max(Z) - min(Z)) / number_of_ticks)))
plt.show()
fig.savefig(figure_name3d)
plt.show()
# draw gradient graph
Z_new = np.linspace(Z.min(), Z.max(), 500)
bspl = splrep(Z, gradiet_vals, s=5)
bspl_y = splev(Z_new, bspl)
smooth_df = pd.DataFrame({'Z': Z_new, 'data': bspl_y})
smooth_df.to_csv("smoothen_y.csv", index=False)
# smooth_df['min'] = smooth_df.Y_Smooth[(smooth_df.Y_Smooth.shift(1) > smooth_df.Y_Smooth) & (smooth_df.Y_Smooth.shift(-1) > smooth_df.Y_Smooth)]
# plt.scatter(smooth_df.index, df['min'], c='r')
# smooth_df.Y_Smooth.plot()
# filt_grad=medfilt(gradiet_vals,)
# fig=plt.figure()
fig, ax = plt.subplots(2, 1)
ax[0].plot(X, Y)
def normalized_hilbert(self, s):
"""
Perform the "Normalized" Hilbert transform (Huang 2008 sec. 3.1) on the IMF s, decomposing the
signal s into AM and FM components. Returns am,fm,phase,ifreq - am is the AM component, fm is the FM
component, phase is the the arccos of fm, and ifreq is the instantaneous frequency.
"""
x = copy.copy(s)
iter = 0
converged = False
while not converged:
#take the absolute value of the IMF and find the extrema
absx = np.abs(x)
mini, maxi = find_extrema(absx)
if len(mini) == 0 or len(maxi) == 0:
converged = True
break
spline_order = 3
#reflect first and last maxima to remove edge effects for interpolation
left_padding = maxi[0]
right_padding = len(x) - maxi[-1]
x_padded = np.zeros([len(x) + left_padding + right_padding])
x_padded[left_padding:-right_padding] = absx
x_padded[0] = absx[maxi[0]]
x_padded[-1] = absx[maxi[-1]]
#create new array of extremas
new_maxi = [i + left_padding for i in maxi]
new_maxi.insert(0, 0)
new_maxi.append(len(x_padded) - 1)
#fit a cubic spline to the extrema of the absolute value of the signal
if len(maxi) <= 3:
spline_order = 1
max_spline = splrep(new_maxi, x_padded[new_maxi], k=spline_order)
#use the spline to interpolate over the course of the signal
t = np.arange(0, len(x_padded))
fit_index = range(left_padding, len(x_padded) - right_padding)
env = splev(t[fit_index], max_spline)
"""
plt.figure()
plt.plot(t, x_padded, 'k-')
plt.plot(new_maxi, x_padded[new_maxi], 'ro-', markersize=8)
plt.axis('tight')
plt.suptitle('Iter %d' % iter)
"""
#divide by envelope
x /= env
#check for convergence
iter += 1
if iter >= self.hilbert_max_iter:
converged = True
if (x.max() - 1.0) <= 1e-6:
converged = True
if len(mini) == 0 or len(maxi) == 0:
converged = True
#compute the FM and AM components
fm = x
am = s / fm
#compute the phase
phase = np.arccos(fm)
#compute the instantaneous frequency
ifreq = np.zeros([len(phase)])
ifreq[1:] = np.diff(phase) * self.sample_rate
return am, fm, phase, ifreq
def interpo_flux_conserving(wave,
flux,
ivar,
waveb,
waver,
dw=2,
testing=False):
"""This is a an interpolation algorithm that does trapezoidal integration
to conserve flux. The variance is then propagated correctly. Since
interpolation always introduces correlation in the variance spectrum,
we ignore this correlation byscale the original variance spectrum
to the new variance spectrum.
"""
var = 1. / ivar
pixel_scale = np.median(np.diff(wave))
# print pixel_scale
wave_min = 999
wave_max = 12001
wavelength_mids = np.arange(math.ceil(wave_min),
math.floor(wave_max),
dtype=int,
step=dw)
lower = wave[0]
upper = wave[-1]
good_data = np.where((wave >= waveb) & (wave <= waver))
influx = inter.splrep(wave[good_data], flux[good_data])
invar = inter.splrep(wave[good_data], var[good_data])
low_int = math.ceil(lower)
up_int = math.ceil(upper)
wave_final = []
flux_final = []
var_final = []
for mid_point in wavelength_mids:
inter_flux_mid_left = float(inter.splev(mid_point, influx, ext=3))
inter_var_mid_left = float(inter.splev(mid_point, invar, ext=3))
inter_flux_mid_right = float(inter.splev(mid_point + dw, influx,
ext=3))
inter_var_mid_right = float(inter.splev(mid_point + dw, invar, ext=3))
waves_to_sum = np.where((wave > mid_point)
& (wave < mid_point + dw))[0]
wave_final.append((mid_point + mid_point + dw) / 2.)
if (mid_point >= lower and (mid_point + dw) <= upper):
waves = [mid_point]
fluxes = [inter_flux_mid_left]
variances = [inter_var_mid_left]
for i, w in enumerate(waves_to_sum):
waves.append(wave[w])
fluxes.append(flux[w])
variances.append(var[w])
waves.append(mid_point + dw)
fluxes.append(inter_flux_mid_right)
variances.append(inter_var_mid_right)
new_point = np.trapz(fluxes, x=waves)
flux_final.append(new_point)
diffs = np.diff(waves)
var_tot = 0.
for i in range(len(variances) - 1):
v1 = variances[i]
v2 = variances[i + 1]
var_tot = var_tot + (diffs[i]**2.) * (v1 + v2)
var_tot = var_tot * .25
var_final.append(var_tot)
else:
flux_final.append(0.)
var_final.append(0.)
inter_var = inter.splev(wave_final, invar, ext=3)
s = scale_together(var_final, inter_var)[0]
scale = 1. / s
var_uncorrelated = scale * inter_var
ivar_final = 1. / var_uncorrelated
wave_final = np.asarray(wave_final)
flux_final = np.asarray(flux_final)
ivar_final = np.asarray(ivar_final)
if testing:
var_final = np.asarray(var_final)
data = np.where(
(wave_final > lower + dw) &
(wave_final <
upper - dw)) # padding to avoid interpolation errors near edges
# flux_final[missing_data] = float('NaN')
# ivar_final[missing_data] = float('NaN')
# if testing:
# var_final[missing_data] = float('NaN')
output = np.array([wave_final[data], flux_final[data], ivar_final[data]])
if testing:
interp_wave = output[0, :]
interp_flux = output[1, :]
interp_ivar = output[2, :]
# print scale
plt.plot(wave, var)
plt.plot(interp_wave, var_final)
plt.plot(interp_wave, 1. / interp_ivar)
plt.xlim([7000, 7100])
plt.ylim([-.05e-32, 2.e-32])
plt.show()
return output
def calcLossAnchor(self, Ep, anc_slip_extr1=0.0, anc_slip_extr2=0.0):
'''Creates the attributes lossAnchor and stressAfterLossAnchor of type
array that contains for each point in fineCoordMtr the cumulative
immediate loss of prestressing due to anchorage slip and the stress
after this loss, respectively.
Loss due to friction must be previously calculated
:param Ep: elasic modulus of the prestressing steel
:param anc_slip_extr1: anchorage slip (data provided by the manufacturer
of the anchorage system) at extremity 1 of
the tendon (starting point) (= deltaL)
:param anc_slip_extr2: anchorage slip at extremity 2 of
the tendon (ending point) (= deltaL)
'''
self.projXYcoordZeroAnchLoss = [0, self.fineProjXYcoord[-1]
] # projected coordinates of the
# points near extremity 1 and extremity 2,
#respectively, that delimite the lengths of
# tendon affected by the loss of prestress
# due to the anchorages slip
#Initialization values
lossAnchExtr1 = np.zeros(len(self.fineScoord))
lossAnchExtr2 = np.zeros(len(self.fineScoord))
if anc_slip_extr1 > 0:
self.slip1 = Ep * anc_slip_extr1
self.tckLossFric = interpolate.splrep(
self.fineScoord, self.stressAfterLossFrictionOnlyExtr1, k=3)
if self.fAnc_ext1(self.fineScoord[-1]) < 0: #the anchorage slip
#affects all the tendon length
lackArea = -2 * self.fAnc_ext1(self.fineScoord[-1])
excess_delta_sigma = lackArea / self.getCumLength().item(-1)
sCoordZeroLoss = self.fineScoord[-1]
else:
# we use newton_krylov solver to find the zero of function
# fAnc_ext1 that gives us the point from which the tendon is
# not affected by the anchorage slip. Tolerance and relative
# step is given as parameters in order to enhance convergence
tol = self.slip1 * 1e-6
sCoordZeroLoss = optimize.newton_krylov(
F=self.fAnc_ext1,
xin=self.fineScoord[-1] / 2.0,
rdiff=0.1,
f_tol=tol) #point from which the tendon is not
#affected by the anchorage slip
self.projXYcoordZeroAnchLoss[0] = self.ScoordToXYprojCoord(
sCoordZeroLoss.item(0))
excess_delta_sigma = 0
stressSCoordZeroLoss = interpolate.splev(
sCoordZeroLoss, self.tckLossFric,
der=0) #stress in that point (after loss due to friction)
condlist = [self.fineScoord <= sCoordZeroLoss]
choicelist = [
2 *
(self.stressAfterLossFrictionOnlyExtr1 - stressSCoordZeroLoss)
+ excess_delta_sigma
]
lossAnchExtr1 = np.select(condlist, choicelist)
if anc_slip_extr2 > 0:
self.slip2 = Ep * anc_slip_extr2
self.tckLossFric = interpolate.splrep(
self.fineScoord, self.stressAfterLossFrictionOnlyExtr2, k=3)
if self.fAnc_ext2(self.fineScoord[0]) < 0: #the anchorage slip
#affects all the tendon length
lackArea = -2 * self.fAnc_ext2(self.fineScoord[0])
excess_delta_sigma = lackArea / self.getCumLength().item(-1)
sCoordZeroLoss = self.fineScoord[0]
else:
# we use newton_krylov solver to find the zero of function
# fAnc_ext1 that gives us the point from which the tendon is
# not affected by the anchorage slip
tol = self.slip2 * 1e-6
sCoordZeroLoss = optimize.newton_krylov(
self.fAnc_ext2,
self.fineScoord[-1] / 2.0,
rdiff=0.1,
f_tol=tol) #point from which the tendon is affected
#by the anchorage slip
self.projXYcoordZeroAnchLoss[1] = self.ScoordToXYprojCoord(
sCoordZeroLoss.item(0))
excess_delta_sigma = 0
stressSCoordZeroLoss = interpolate.splev(
sCoordZeroLoss, self.tckLossFric,
der=0) #stress in that point (after loss due to friction)
condlist = [self.fineScoord >= sCoordZeroLoss]
choicelist = [
2 * (self.stressAfterLossFriction - stressSCoordZeroLoss) +
excess_delta_sigma
]
lossAnchExtr2 = np.select(condlist, choicelist)
self.lossAnch = lossAnchExtr1 + lossAnchExtr2
self.stressAfterLossAnch = self.stressAfterLossFriction - self.lossAnch
def CCF(spec,
model_path='/dummy/path/',
doplot=False,
plot_dir='/home/rabrahm/',
plot_name='MY_LUP',
Li=4500.,
Lf=6300.,
npools=1,
base='../utils/Correlation/'):
"""
This function finds an aproximation to the stellar parameters (Teff, log(g), [Fe/H])
of the input echelle spectrum using a CCF with model spectra. This code also is
constructed to find the radial velocity of the star and v*sin(i).
"""
global It, L_Gl, F_Gl, ons, velo2, wat, lux
lux = 299792.458
L1, F1 = spec[0, :, :], spec[5, :, :]
for i in range(F1.shape[0]):
I = np.where(np.isnan(F1[i]) == True)[0]
F1[i][I] = 1.
#width_path = '/home/rabrahm/Desktop/corr2/'
#slines_path = '/home/rabrahm/Desktop/corr2/'
SLi, SLf = numpy.loadtxt(base + 'lines2.dat', dtype=None, unpack=True)
SLi = ToVacuum(SLi)
SLf = ToVacuum(SLf)
AT,AG,AZ,A000,A025,A050,A075,A100,A150,A200,A250,A300,A350,A400,A450,A500 =\
numpy.loadtxt(base+'anchos50000.dat',dtype=None,unpack=True)
vsini = [
0.0, 2.5, 5.0, 7.5, 10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0,
50.0
]
or01 = 0
for i in range(L1.shape[0]):
I = numpy.where(L1[i] < Lf)[0]
if len(I) > 0:
or01 = i
break
or02 = L1.shape[0] - 1
for i in range(L1.shape[0]):
I = numpy.where(L1[i] < Li)[0]
if len(I) > 0:
or02 = i
break
or03 = 0
for i in range(L1.shape[0]):
I = numpy.where(L1[i] < 6250.0)[0]
if len(I) > 0:
or03 = i
break
or04 = L1.shape[0] - 1
for i in range(L1.shape[0]):
I = numpy.where(L1[i] < 5500.0)[0]
if len(I) > 0:
or04 = i
break
or05 = 0
for i in range(L1.shape[0]):
I = numpy.where(L1[i] < 5190.0)[0]
W = numpy.where(L1[i] < 5170.0)[0]
if len(I) > 0 and len(W) > 0:
or05 = i
break
#print or01,or02,or03,or04,or05
guess = [1.0, 1.0, 1.0]
L = L1[or01:or02]
F = F1[or01:or02]
Lm = L1[or03:or04]
Fm = F1[or03:or04]
Lg = L1[or05]
Fg = F1[or05]
bad_lines = [[6860, 6900], [6550, 6580], [6270, 6320], [4850, 4880]]
ons = bad_orders(L, bad_lines)
modi = 'R_0.0_5000_30_p00p00.ms.fits'
#print 'Radial velocity calculation via CCF with: '+modi
sci = pyfits.getdata(model_path + 'vsini_0.0/' + modi)
hdi = pyfits.getheader(model_path + 'vsini_0.0/' + modi)
wam1 = ToVacuum(numpy.arange(len(sci)) * hdi['CD1_1'] + hdi['CRVAL1'])
Im = numpy.where((wam1 > 5400.0) & (wam1 < 6350.0))[0]
wam = wam1[Im]
flm = sci[Im]
Ig = numpy.where((wam1 > 5100.0) & (wam1 < 5250.0))[0]
wag = wam1[Ig]
It = numpy.where((wam1 > 4000.0) & (wam1 < 7500.0))[0]
wat = wam1[It]
for i in range(Lm.shape[0]):
I = numpy.where((Fm[i] != 0.0) & (Fm[i] < 2.0))[0]
Ls = Lm[i][I]
Fs = Fm[i][I]
I = numpy.where((wam > Ls[0] - 5.0) & (wam < Ls[-1] + 5.0))[0]
MLs = wam[I]
MFs = flm[I]
vv, cc = vels.CCF(MLs, MFs, Ls, Fs, -200.0, 200.0)
if i == 0:
ccf = numpy.array(cc) * (Ls[-1] - Ls[0])
nor = Ls[-1] - Ls[0]
else:
ccf = ccf + numpy.array(cc) * (Ls[-1] - Ls[0])
nor = nor + (Ls[-1] - Ls[0])
ccf = ccf / nor
vv = numpy.array(vv)
B = 0.5 * (ccf[0] + ccf[-1])
A = numpy.max(ccf) - B
med = vv[numpy.where(ccf == numpy.max(ccf))[0]]
sig = 20.0
guess1 = [B, A, med, sig]
ajustep = optimize.leastsq(res_gauss1, guess1, args=(ccf, vv))
velo = ajustep[0][2]
#print 'The initial radial velocity is: '+str(velo)+' km/s'
#print 'Determining parameters of the initial model'
vecti = [3500, 4000, 4500, 5000, 5500, 6500]
vecgi = [0.0, 1.5, 3.0, 4.5]
#veczi = [-2.0,-1.0,0.0]
veczi = [-1.0, 0.0]
ccmax = 0
names = []
cc = 0
nor = 0
for g in vecgi:
for z in veczi:
for t in vecti:
nam = get_name(t, g, z)
names.append(nam)
namemax = get_name(5500, 4.5, 0.0)
TEI = 5500
MEI = 0.0
LGI = 4.5
for nam in names:
if ((os.access(model_path + 'vsini_0.0/R_0.0_' + nam,
os.F_OK) == True)):
mod = pyfits.getdata(model_path + 'vsini_0.0/R_0.0_' + nam)
flm = mod[Im]
cc = 0.0
nor = 0.0
for o in range(Lm.shape[0]):
I = numpy.where(Fm[i] != 0.0)[0]
Ls = Lm[i][I]
Fs = Fm[i][I]
I = numpy.where((wam > Ls[0] - 5.0) & (wam < Ls[-1] + 5.0))[0]
MLs = wam[I] * (1 + velo / lux)
MFs = flm[I]
tck = interpolate.splrep(MLs, MFs, k=3, s=0)
NMFs = interpolate.splev(Ls, tck, der=0)
cc = cc + integrate.simps(
NMFs[1:-1] * Fs[1:-1], Ls[1:-1]) / math.sqrt(
integrate.simps(Fs[1:-1] * Fs[1:-1], Ls[1:-1]) *
integrate.simps(NMFs[1:-1] * NMFs[1:-1], Ls[1:-1])) * (
Ls[-1] - Ls[0])
nor = nor + (Ls[-1] - Ls[0])
cc = cc / nor
if cc >= ccmax:
ccmax = cc
namemax = nam
mod = pyfits.getheader(model_path + 'vsini_0.0/R_0.0_' + namemax)
TEI = mod['TEFF']
#print 'Teff (initial) = '+str(TEI)+' K'
if TEI <= 4000:
rot = 5.0
LGI = 3.0
MTI = 0.0
late = True
velo2 = velo
else:
late = False
t = TEI
vecgi = [1.0, 2.0, 3.0, 4.0]
#veczi = [-2.0,-1.0,0.0]
veczi = [-1.0, 0.0]
dif = 1000.0
for z in veczi:
vals = []
di = 1000
meg = 3.0
for g in vecgi:
nam = get_name(t, g, z)
if ((os.access(model_path + 'vsini_0.0/R_0.0_' + nam,
os.F_OK) == True)):
mod = pyfits.getdata(model_path + 'vsini_0.0/R_0.0_' + nam)
flm = mod[Im]
flm = el_stl(wam, flm, SLi, SLf)
intfl = 0.0
intflm = 0.0
di = 1000
for o in range(Lm.shape[0]):
I = numpy.where(Fm[i] != 0.0)[0]
Ls = Lm[i][I]
Fs = Fm[i][I]
Fs = el_stl(Ls, Fs, SLi * (1 + velo / lux),
SLf * (1 + velo / lux))
I = numpy.where((wam > Ls[0] - 5.0)
& (wam < Ls[-1] + 5.0))[0]
MLs = wam[I] * (1 + velo / lux)
MFs = flm[I]
tck = interpolate.splrep(MLs, MFs, k=3, s=0)
NMFs = interpolate.splev(Ls, tck, der=0)
intfl = intfl + integrate.simps(
Fs[1:-1] * Fs[1:-1], Ls[1:-1])
intflm = intflm + integrate.simps(
NMFs[1:-1] * NMFs[1:-1], Ls[1:-1])
intfl = math.sqrt(intfl)
intflm = math.sqrt(intflm)
dif1 = math.sqrt((intflm - intfl)**2)
vals.append(dif1)
if dif1 < di:
di = dif1
meg = g
dif2 = numpy.mean(vals)
#print z,dif2
if dif2 < dif:
dif = dif2
LGI = meg
MEI = z
TEI = t
#print '[Fe/H] (initial) = '+str(MEI)
vecgi = [0.5, 1.5, 2.5, 3.5, 4.5]
cfi2 = 0.0
for g in vecgi:
nam = get_name(TEI, g, MEI)
if ((os.access(model_path + 'vsini_0.0/R_0.0_' + nam,
os.F_OK) == True)):
mod = pyfits.getdata(model_path + 'vsini_0.0/R_0.0_' + nam)
mflg = mod[Ig]
I = numpy.where(Fg != 0.0)[0]
Ls = Lg[I]
Fs = Fg[I]
I = numpy.where((wag > Ls[0] - 5.0) & (wag < Ls[-1] + 5.0))[0]
MLs = wag[I] * (1 + velo / lux)
MFs = mflg[I]
tck = interpolate.splrep(MLs, MFs, k=3, s=0)
NMFs = interpolate.splev(Ls, tck, der=0)
cc2 = integrate.simps(Fs[1:-1] * NMFs[1:-1]) / math.sqrt(
integrate.simps(Fs[1:-1] * Fs[1:-1]) *
integrate.simps(NMFs[1:-1] * NMFs[1:-1]))
#print g,cc2
if cc2 > cfi2:
cfi2 = cc2
LGI = g
#print 'Log(g) (initial) = '+str(LGI)
itera = 0
maximo = 0
calculated = []
rotss = []
vecR = []
vecT = []
vecG = []
vecZ = []
vecCF = []
while itera < 4:
if late == False:
MOG = get_name(TEI, LGI, MEI)
sc = pyfits.getdata(model_path + 'vsini_0.0/R_0.0_' + MOG)
#print '-Calculating radial shift and v*sin(i) with model: '+MOG
flm = sc[Im]
ies = []
flm = el_stl(wam, flm, SLi, SLf)
for i in range(Lm.shape[0]):
I = numpy.where(Fm[i] != 0.0)[0]
Ls = Lm[i][I]
Fs = Fm[i][I]
Fs = el_stl(Ls, Fs, SLi * (1 + velo / lux),
SLf * (1 + velo / lux))
I = numpy.where((wam > Ls[0] - 5.0) & (wam < Ls[-1] + 5.0))[0]
ies.append(I)
MLs = wam[I]
MFs = flm[I]
vv, cc = vels.CCF(MLs, MFs, Ls, Fs, -200, 200)
if i == 0:
ccf = numpy.array(cc) * (Ls[-1] - Ls[0])
nor = Ls[-1] - Ls[0]
else:
ccf = ccf + numpy.array(cc) * (Ls[-1] - Ls[0])
nor = nor + (Ls[-1] - Ls[0])
nor2 = 1.
ccf = ccf / nor
vv = numpy.array(vv)
B = 0.5 * (ccf[0] + ccf[-1])
A = numpy.max(ccf) - B
med = vv[numpy.where(ccf == numpy.max(ccf))[0]]
sig = 20.0
guess1 = [B, A, med, sig]
ajustep = optimize.leastsq(res_gauss1, guess1, args=(ccf, vv))
velo2 = ajustep[0][2]
sig2 = ajustep[0][3]
sig2 = math.sqrt(sig2 * sig2)
#plt.plot(vv,ccf,vv,gauss1(ajustep[0],vv))
#plt.show()
#print 'radial velocity = '+str(velo2)+' km/s'
#print 'Sigma = '+str(sig2)+' km/s'
"""
vi = 0.0
difsigmin = 1000
while vi <= 20.0:
ai = 0
if ( (os.access(model_path+'vsini_'+str(vi)+'/R_'+str(vi)+'_'+MOG,os.F_OK) == True)):
modt = pyfits.getdata(model_path+'vsini_'+str(vi)+'/R_'+str(vi)+'_'+MOG)
flm2 = modt[Im]
flm2 = el_stl(wam,flm2,SLi,SLf)
for I in ies:
Fs = flm[I]
Ls = wam[I]
Fs = el_stl(Ls,Fs,SLi,SLf)
MFs = flm2[I]
vv2,cc2 = vels.CCF(Ls,MFs,Ls,Fs,-200,200)
if ai == 0:
ccf2 = numpy.array(cc2)*(Ls[-1]-Ls[0])
nor2 = Ls[-1]-Ls[0]
else:
ccf2 = ccf2 + numpy.array(cc2)*(Ls[-1]-Ls[0])
nor2 = nor2 + (Ls[-1]-Ls[0])
ai += 1
cc2 = ccf2/nor2
vv2 = numpy.array(vv2)
B3 = 0.5*(cc2[0]+cc2[-1])
A3 = numpy.max(cc2)-B3
med3 = 0.0
sig3 = 20.0
guess1 = [B3,A3,med3,sig3]
ajustep=optimize.leastsq(res_gauss1,guess1,args=(cc2,numpy.array(vv2)))
cte3 = ajustep[0][0]
no3 = ajustep[0][1]
med3 = ajustep[0][2]
sig3 = ajustep[0][3]
#plt.plot(vv2,cc2)
print vi,sig3
difsig = math.sqrt((sig2-sig3)**2)
if difsig < difsigmin:
difsigmin = difsig
rot = vi
ai +=1
if vi <= 7.5:
vi = vi+2.5
elif vi < 50.0:
vi = vi+5.0
else:
break
#plt.show()
"""
if sig2 >= vsini[0]:
I = numpy.where((AT == TEI) & (AG == LGI) & (AZ == MEI))[0][0]
anchos = numpy.array([
A000[I], A025[I], A050[I], A075[I], A100[I], A150[I],
A200[I], A250[I], A300[I], A350[I], A400[I], A450[I],
A500[I]
])
kis = 0
while kis < len(anchos) - 1:
if anchos[kis] > anchos[kis + 1]:
portemp = anchos[kis]
anchos[kis] = anchos[kis + 1]
anchos[kis + 1] = portemp
kis += 1
tck = interpolate.splrep(anchos, numpy.array(vsini), k=3, s=0)
calrot = interpolate.splev(sig2, tck, der=0)
difs = (numpy.array(vsini) - calrot)**2
AI = int(numpy.where(difs == numpy.min(difs))[0])
rot = vsini[AI]
else:
rot = vsini[0]
calrot = 0.0
#rot = 2.5
#print 'v*sin(i) = '+str(calrot)+' km/s'
RI = numpy.where(numpy.array(rotss) == rot)[0]
if len(RI) > 0:
break
else:
model_path1 = model_path + "vsini_" + str(rot) + "/"
""" conociendo la velocidad radial realizo una busqueda gruesa de parametros estelares calculando el maximo de la CCF"""
#print "-Searching the optimal stellar model"
#maxT,maxG,maxZ,maxCor,maxvs = 5500,4.0,0.0,0.0,0.0
maxCor = 0.0
if TEI >= 3500 and TEI <= 4250:
modT = [3500, 4000, 4500, 5000]
else:
modT = [4000, 4500, 5000, 5500, 6000, 6500, 7000]
modG = [1.0, 2.5, 4.0]
#modZ = [-2.0,-1.0,0.0]
modZ = [-1.0, 0.0]
MOD, MOD2 = [], []
i = 0
while i < len(modZ):
ig = 0
while ig < len(modG):
it = 0
while it < len(modT):
MK = 'R_' + str(rot) + '_' + get_name(
modT[it], modG[ig], modZ[i])
if os.access(model_path1 + MK, os.F_OK):
MOD.append(MK)
MOD2.append(model_path1 + MK)
it = it + 1
ig = ig + 1
i = i + 1
MOD = np.array(MOD)
MOD2 = np.array(MOD2)
all_pars = np.vstack((MOD, np.zeros(len(MOD)) + velo2))
L_Gl, F_Gl = L.copy(), F.copy()
p = Pool(npools)
xc_values = np.array((p.map(corr_p, MOD2)))
p.terminate()
I_min = np.argmax(xc_values)
hd = pyfits.getheader(MOD2[I_min])
maxCor = xc_values[I_min]
maxG = hd['LOG_G']
maxT = hd['TEFF']
maxZ = hd['FEH']
maxvs = hd['VSINI']
#print MOD2[I_min]
"""
print xc_values
print MOD2[I_min],I_min
print dfgh
for m in MOD:
hd = pyfits.getheader(model_path1+m)
T = hd['TEFF']
G = hd['LOG_G']
Z = hd['FEH']
vs = hd['VSINI']
sc = pyfits.getdata(model_path1+m)
FF = sc[It]
mwa = wat*(1+velo2/lux)
NCCF = corr(L,F,mwa,FF,ons)
#print T,G,Z,vs,NCCF
if NCCF > maxCor:
maxCor = NCCF
maxG = G
maxT = T
maxZ = Z
maxvs = vs
elif NCCF<0:
print "Problem with spectrum!!! -> Negative value of CCF."
maxG = 4.5
maxT = 5500
maxZ = 0
maxvs = 0
"""
#print 'maxgrueso',maxT,maxG,maxZ,maxvs
""" A partir de los parametros encontrados en la busqueda gruesa procedo a constrenir los limites de la busqueda fina"""
#Tfin,Gfin,Zfin,rotfin,velfin = 5500,4.0,0.0,0.0,0.0
""" Ahora se buscan los par'ametros estelares optimos mediante una exploracion fina"""
if maxT == 3500 or maxT == 4000:
modT = [3500, 3750, 4000, 4250, 4500]
elif maxT == 7000 or maxT == 6500:
modT = [6000, 6250, 6500, 6750, 7000]
else:
modT = [
maxT - 750, maxT - 500, maxT - 250, maxT, maxT + 250,
maxT + 500, maxT + 750
]
if maxG == 1.0:
modG = [0.0, 0.5, 1.0, 1.5, 2.0, 2.5]
if maxG == 2.5:
modG = [1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0]
if maxG == 4.0:
modG = [2.5, 3.0, 3.5, 4.0, 4.5, 5.0]
if maxZ == -2.0:
modZ = [-2.5, -2.0, -1.5, -1.0]
if maxZ == -1.0:
modZ = [-1.5, -1.0, -0.5, 0.0]
if maxZ == 0.0:
modZ = [-0.5, 0.0, 0.2, 0.5]
MOD, MOD2 = [], []
for i in modZ:
for ig in modG:
for it in modT:
MK = 'R_' + str(rot) + '_' + get_name(it, ig, i)
if os.access(model_path1 + MK, os.F_OK):
MOD.append(MK)
MOD2.append(model_path1 + MK)
MOD2 = np.array(MOD2)
L_Gl, F_Gl = L.copy(), F.copy()
p = Pool(npools)
xc_values = np.array((p.map(corr_p, MOD2)))
p.terminate()
I_min = np.argmax(xc_values)
hd = pyfits.getheader(MOD2[I_min])
maxCor = xc_values[I_min]
maxG = hd['LOG_G']
maxT = hd['TEFF']
maxZ = hd['FEH']
maxvs = hd['VSINI']
#print MOD2[I_min]
"""
#maxT,maxG,maxZ,maxCor = 5500,4.0,0,0
maxCor = 0.0
for m in MOD:
calculated.append(m)
hd = pyfits.getheader(model_path1+m)
T = hd['TEFF']
G = hd['LOG_G']
Z = hd['FEH']
sc = pyfits.getdata(model_path1+m)
FF = sc[It]
mwa = wat*(1+velo2/lux)
NCCF = corr(L,F,mwa,FF,ons)
vecT.append(T)
vecG.append(G)
vecZ.append(Z)
vecR.append(rot)
vecCF.append(NCCF)
#print T,G,Z,NCCF
if NCCF > maxCor:
maxCor = NCCF
maxT = T
maxG = G
maxZ = Z
elif NCCF < 0:
print "Problem with spectrum!!! -> Negative value of CCF."
maxG = 4.5
maxT = 5500
maxZ = 0
maxvs = 0
"""
#print "maxfino",maxT,maxG,maxZ,maxCor
TEI = maxT
LGI = maxG
MEI = maxZ
ultrot = rot
if maxCor > maximo:
maximo = maxCor
Tfin, Gfin, Zfin, rotfin, velfin = maxT, maxG, maxZ, rot, velo2
#Tf,Gf,Zf = intert,interg,maZ
late = False
rotss.append(rot)
itera = itera + 1
if maximo == 0:
Tfin, Gfin, Zfin, rotfin, velfin = 5500, 4.5, 0, 0, velo2
#print 'Pars fase 0:', Tfin, Gfin, Zfin,rotfin,maximo
mejor = False
if rotfin == 0.0:
nrot = [0.0, 2.5]
elif rotfin == 2.5:
nrot = [0.0, 2.5, 5.0]
elif rotfin == 5.0:
nrot = [2.5, 5.0, 7.5]
elif rotfin == 7.5:
nrot = [5.0, 7.5, 10.0]
else:
nrot = [rotfin - 5.0, rotfin, rotfin + 5.0]
if Tfin == 3500:
nT = [3500, 3750, 4000]
elif Tfin == 7000:
nT = [6500, 6750, 7000]
else:
nT = [Tfin - 250, Tfin, Tfin + 250]
if Gfin == 0.0:
nG = [0.0, 0.5, 1.0]
elif Gfin == 0.5:
nG = [0.0, 0.5, 1.0]
elif Gfin == 4.5:
nG = [4.0, 4.5, 5.0]
elif Gfin == 5.0:
nG = [4.0, 4.5, 5.0]
else:
nG = [Gfin - 0.5, Gfin, Gfin + 0.5]
if Zfin == -2.5:
nZ = [-2.5, -2.0, -1.5]
elif Zfin == 0.5:
nZ = [0.0, 0.2, 0.5]
elif Zfin == 0.2:
nZ = [0.0, 0.2, 0.5]
elif Zfin == 0.0:
nZ = [-0.5, 0.0, 0.2, 0.5]
else:
nZ = [Zfin - 0.5, Zfin, Zfin + 0.5]
for v in nrot:
model_path2 = model_path + 'vsini_' + str(v) + '/'
names = []
calc = numpy.array(calculated)
for t in nT:
for g in nG:
for z in nZ:
nam = 'R_' + str(v) + '_' + get_name(t, g, z)
I = numpy.where(calc == nam)[0]
if len(I) == 0 and os.access(model_path2 + nam, os.F_OK):
names.append(nam)
for fits in names:
calculated.append(fits)
hd = pyfits.getheader(model_path2 + fits)
T = hd['TEFF']
G = hd['LOG_G']
Z = hd['FEH']
sc = pyfits.getdata(model_path2 + fits)
FF = sc[It]
mwa = wat * (1 + velfin / lux)
NCCF = corr(L, F, mwa, FF, ons)
vecT.append(T)
vecG.append(G)
vecZ.append(Z)
vecCF.append(NCCF)
vecR.append(v)
#print T,G,Z,NCCF
if NCCF > maximo:
mejor = True
maximo = NCCF
Tfin = T
Gfin = G
Zfin = Z
rotfin = v
#print Tfin,Gfin,Zfin,rotfin,maximo
maximCCF = maximo
total_inter = 1
if total_inter == 0:
deltaV = 0.5
deltaG = 0.05
deltaT = 50.0
deltaZ = 0.1
vCF = numpy.array(vecCF)
vvT = numpy.array(vecT)
vvG = numpy.array(vecG)
vvZ = numpy.array(vecZ)
vvV = numpy.array(vecR)
ejeT = numpy.arange(numpy.min(nT), numpy.max(nT) + deltaT, deltaT)
ejeV = numpy.arange(numpy.min(nrot), numpy.max(nrot) + deltaV, deltaV)
ejeG = numpy.arange(numpy.min(nG), numpy.max(nG) + deltaG, deltaG)
ejeZ = numpy.arange(numpy.min(nZ), numpy.max(nZ) + deltaZ, deltaZ)
lejeV = len(ejeV)
lejeG = len(ejeG)
lejeT = len(ejeT)
lejeZ = len(ejeZ)
matCCF = numpy.zeros([lejeT, lejeG, lejeZ, lejeV], float)
for v in nrot:
posV = int(round((v - ejeV[0]) / deltaV))
for z in nZ:
posZ = int(round((z - ejeZ[0]) / deltaZ))
for g in nG:
posG = int(round((g - ejeG[0]) / deltaG))
I = numpy.where((vvV == v) & (vvG == g) & (vvZ == z))[0]
if len(I) > 0:
vTt, vCFt = orden(vvT[I], vCF[I])
if len(I) > 3:
tck = interpolate.splrep(vTt, vCFt, k=3, s=0)
ynew = interpolate.splev(ejeT, tck, der=0)
elif len(I) > 1:
tck = interpolate.splrep(vTt,
vCFt,
k=len(I) - 1,
s=0)
ynew = interpolate.splev(ejeT, tck, der=0)
else:
ynew = numpy.zeros(len(ejeT), float) + vCFt[0]
matCCF[:, posG, posZ, posV] = ynew
for v in nrot:
posV = int(round((v - ejeV[0]) / deltaV))
for z in nZ:
posZ = int(round((z - ejeZ[0]) / deltaZ))
for t in ejeT:
posT = int(round((t - ejeT[0]) / deltaT))
y1 = matCCF[posT, :, posZ, posV]
I = numpy.where(y1 != 0.0)[0]
y1b = y1[I]
x1b = ejeG[I]
if len(I) > 0:
if len(I) > 3:
tck = interpolate.splrep(x1b, y1b, k=3, s=0)
ynew = interpolate.splev(ejeG, tck, der=0)
elif len(I) > 1:
tck = interpolate.splrep(x1b,
y1b,
k=len(I) - 1,
s=0)
ynew = interpolate.splev(ejeG, tck, der=0)
else:
ynew = numpy.zeros(len(ejeG), float) + y1b[0]
matCCF[posT, :, posZ, posV] = ynew
for v in nrot:
posV = int(round((v - ejeV[0]) / deltaV))
for t in ejeT:
posT = int(round((t - ejeT[0]) / deltaT))
for g in ejeG:
posG = int(round((g - ejeG[0]) / deltaG))
y1 = matCCF[posT, posG, :, posV]
I = numpy.where(y1 != 0.0)[0]
y1b = y1[I]
x1b = ejeZ[I]
if len(I) > 0:
if len(I) > 3:
tck = interpolate.splrep(x1b, y1b, k=3, s=0)
ynew = interpolate.splev(ejeZ, tck, der=0)
elif len(I) > 1:
tck = interpolate.splrep(x1b,
y1b,
k=len(I) - 1,
s=0)
ynew = interpolate.splev(ejeZ, tck, der=0)
else:
ynew = numpy.zeros(len(ejeZ), float) + y1b[0]
matCCF[posT, posG, :, posV] = ynew
for t in ejeT:
posT = int(round((t - ejeT[0]) / deltaT))
for g in ejeG:
posG = int(round((g - ejeG[0]) / deltaG))
for z in ejeZ:
posZ = int(round((z - ejeZ[0]) / deltaZ))
y1 = matCCF[posT, posG, posZ, :]
I = numpy.where(y1 != 0.0)[0]
y1b = y1[I]
x1b = ejeV[I]
if len(I) > 0:
if len(I) > 3:
tck = interpolate.splrep(x1b, y1b, k=3, s=0)
ynew = interpolate.splev(ejeV, tck, der=0)
elif len(I) > 1:
tck = interpolate.splrep(x1b,
y1b,
k=len(I) - 1,
s=0)
ynew = interpolate.splev(ejeV, tck, der=0)
else:
ynew = numpy.zeros(len(ejeV), float) + y1b[0]
matCCF[posT, posG, posZ, :] = ynew
I = numpy.where(matCCF == numpy.max(matCCF))
intert = ejeT[I[0]]
interg = ejeG[I[1]]
interz = ejeZ[I[2]]
interv = ejeV[I[3]]
maximCCF = numpy.max(CCF)
#print 'interp',intert,interg,interz,interv
elif total_inter == 1:
if Tfin == 3500:
nT = [3500, 3750, 4000, 4250]
elif Tfin == 3750:
nT = [3500, 3750, 4000, 4250]
elif Tfin == 7000:
nT = [6250, 6500, 6750, 7000]
elif Tfin == 6750:
nT = [6250, 6500, 6750, 7000]
else:
nT = [Tfin - 500, Tfin - 250, Tfin, Tfin + 250, Tfin + 500]
if Gfin == 0.0:
nG = [0.0, 0.5, 1.0, 1.5]
elif Gfin == 0.5:
nG = [0.0, 0.5, 1.0, 1.5]
elif Gfin == 4.5:
nG = [3.5, 4.0, 4.5, 5.0]
elif Gfin == 5.0:
nG = [3.5, 4.0, 4.5, 5.0]
else:
nG = [Gfin - 1.0, Gfin - 0.5, Gfin, Gfin + 0.5, Gfin + 1.0]
calc = numpy.array(calculated)
model_path2 = model_path + 'vsini_' + str(rotfin) + '/'
names = []
for t in nT:
for g in nG:
nam = 'R_' + str(rotfin) + '_' + get_name(t, g, Zfin)
I = numpy.where(calc == nam)[0]
if len(I) == 0 and os.access(model_path2 + nam, os.F_OK):
names.append(nam)
for fits in names:
calculated.append(fits)
hd = pyfits.getheader(model_path2 + fits)
T = hd['TEFF']
G = hd['LOG_G']
Z = hd['FEH']
sc = pyfits.getdata(model_path2 + fits)
FF = sc[It]
mwa = wat * (1 + velfin / lux)
NCCF = corr(L, F, mwa, FF, ons)
vecZ.append(Z)
vecT.append(T)
vecG.append(G)
vecR.append(rotfin)
vecCF.append(NCCF)
VZ = numpy.array(vecZ)
VR = numpy.array(vecR)
VT = numpy.array(vecT)
VG = numpy.array(vecG)
VF = numpy.array(vecCF)
I = numpy.where((VZ == Zfin) & (VR == rotfin))[0]
VT2 = VT[I]
VG2 = VG[I]
VF2 = VF[I]
deltaT = 50.0
deltaG = 0.05
ejeT = numpy.arange(numpy.min(numpy.array(nT)),
numpy.max(numpy.array(nT)) + deltaT, deltaT)
ejeG = numpy.arange(numpy.min(numpy.array(nG)),
numpy.max(numpy.array(nG)) + deltaG, deltaG)
lejeT = len(ejeT)
lejeG = len(ejeG)
matCCF = numpy.zeros([lejeT, lejeG], float)
for g in nG:
pos = int(round((g - ejeG[0]) / deltaG))
I = numpy.where(VG2 == g)[0]
if len(I) > 0:
vTt, vCFt = orden(VT2[I], VF2[I])
#print vTt,vCFt
if len(I) > 3:
tck = interpolate.splrep(vTt, vCFt, k=3, s=0)
ynew = interpolate.splev(ejeT, tck, der=0)
elif len(I) > 1:
tck = interpolate.splrep(vTt, vCFt, k=len(I) - 1, s=0)
ynew = interpolate.splev(ejeT, tck, der=0)
else:
ynew = numpy.zeros(len(ejeT), float) + vCFt[0]
matCCF[:, pos] = ynew
for t in ejeT:
pos1 = int(round((t - ejeT[0]) / deltaT))
y1 = matCCF[pos1, :]
I = numpy.where(y1 != 0.0)[0]
y1b = y1[I]
x1b = ejeG[I]
if len(I) > 0:
if len(I) > 3:
tck = interpolate.splrep(x1b, y1b, k=3, s=0)
ynew = interpolate.splev(ejeG, tck, der=0)
elif len(I) > 1:
tck = interpolate.splrep(x1b, y1b, k=len(I) - 1, s=0)
ynew = interpolate.splev(ejeG, tck, der=0)
else:
ynew = numpy.zeros(len(ejeG), float) + y1b[0]
matCCF[pos1, :] = ynew
I = numpy.where(matCCF == numpy.max(matCCF))
intert = ejeT[I[0]][0]
interg = ejeG[I[1]][0]
interz = Zfin
interv = rotfin
#print intert,interg
maximCCF = numpy.max(matCCF)
else:
intert, interg, interz, interv = Tfin, Gfin, Zfin, rotfin
#print 'HI'
if doplot:
nam = 'R_' + str(rotfin) + '_' + get_name(Tfin, Gfin, Zfin)
hd = pyfits.getheader(model_path2 + nam)
sc = pyfits.getdata(model_path2 + nam)
PWAV = ToVacuum(numpy.arange(len(sc)) * hd['CD1_1'] + hd['CRVAL1'])
PWAV = PWAV * (1 + velfin / lux)
for i in range(L1.shape[0]):
I = numpy.where((PWAV > L1[i, 0]) & (PWAV < L1[i, -1]))[0]
#print L1[i]
#print F1[i]
#print i
f = figure()
ylim(0., 1.01)
plot(L1[i], F1[i])
plot(PWAV[I], sc[I])
xlabel('wavelenth [A]')
ylabel('Continuum Normalized Flux')
savefig(plot_dir + plot_name + '_' + str(int(L1[i, 0])) + '_' +
str(int(L1[i, -1])) + '.pdf',
format='pdf')
return [intert, interg, interz, interv, velfin, maximCCF]
(currentCycle, int(data.split(',')[0].strip(' (')),
int(data.split(',')[1].strip(' )')) / 1024 / 1024))
if topic == 'router-network-usage':
routerNetworkUsage.append(
(currentCycle, int(data.split(',')[0].strip(' (')),
int(data.split(',')[1].strip(' )')) / 1024 / 1024))
if topic == 'open-channel':
channelCount += 1
if topic == 'close-channel':
channelCount -= 1
algName = algorithmName(stdoutFile)
x_val = [e[0] for e in avgChannelCounts]
y_val = [e[1] for e in avgChannelCounts]
t, c, k = interpolate.splrep(x_val, y_val)
spline = interpolate.BSpline(t, c, k, extrapolate=False)
xx = np.arange(0, 520, 20)
xx[0] = 1
axs[0, 0].plot(xx,
spline(xx),
lineTypes[algName],
label=algNames[algName] + ' ' + scenarioName)
ax = axs[0, 0]
ax.set_xlabel('cycles')
ax.set_ylabel('avg channel count')
for ax in axs.flat:
ax.set_xlim(left=-10, right=510)
ax.grid()
def compute_imf(self, s, plot=False):
"""
Compute an intrinsic mode function from a signal s using sifting.
"""
stop = False
#make a copy of the signal
imf = copy.copy(s)
#find extrema for first iteration
mini, maxi = find_extrema(s)
if len(mini) == 0 or len(maxi) == 0:
return None
#keep track of extrema difference
num_extrema = np.zeros(
[self.sift_stoppage_S,
2]) # first column are maxima, second column are minima
num_extrema[-1, :] = [len(maxi), len(mini)]
iter = 0
while not stop:
#set some things up for the iteration
s_used = s
left_padding = 0
right_padding = 0
#add an extra oscillation at the beginning and end of the signal to reduce edge effects; from Rato et. al (2008) section 3.2.2
if self.sift_remove_edge_effects:
Tl = maxi[0] # index of left-hand (first) maximum
tl = mini[0] # index of left-hand (first) minimum
Tr = maxi[-1] # index of right hand (last) maximum
tr = mini[-1] # index of right hand (last) minimum
#to reduce end effects, we need to extend the signal on both sides and reflect the first and last extrema
#so that interpolation works better at the edges
left_padding = max(Tl, tl)
right_padding = len(s) - min(Tr, tr)
#pad the original signal with zeros and reflected extrema
s_used = np.zeros([len(s) + left_padding + right_padding])
s_used[left_padding:-right_padding] = s
#reflect the maximum on the left side
imax_left = left_padding - tl
s_used[imax_left] = s[Tl]
#reflect the minimum on the left side
imin_left = left_padding - Tl
s_used[imin_left] = s[tl]
#correct the indices on the right hand side so they're useful
trr = len(s) - tr
Trr = len(s) - Tr
#reflect the maximum on the right side
roffset = left_padding + len(s)
imax_right = roffset + trr - 1
s_used[imax_right] = s[Tr]
#reflect the minimum on the right side
imin_right = roffset + Trr - 1
s_used[imin_right] = s[tr]
#extend the array of maxima
new_maxi = [i + left_padding for i in maxi]
new_maxi.insert(0, imax_left)
new_maxi.append(imax_right)
maxi = new_maxi
#extend the array of minima
new_mini = [i + left_padding for i in mini]
new_mini.insert(0, imin_left)
new_mini.append(imin_right)
mini = new_mini
t = np.arange(0, len(s_used))
fit_index = range(left_padding, len(s_used) - right_padding)
#fit minimums with cubic splines
spline_order = 3
if len(mini) <= 3:
spline_order = 1
min_spline = splrep(mini, s_used[mini], k=spline_order)
min_fit = splev(t[fit_index], min_spline)
#fit maximums with cubic splines
spline_order = 3
if len(maxi) <= 3:
spline_order = 1
max_spline = splrep(maxi, s_used[maxi], k=spline_order)
max_fit = splev(t[fit_index], max_spline)
if plot:
plt.figure()
plt.plot(t[fit_index], max_fit, 'r-')
plt.plot(maxi, s_used[maxi], 'ro')
plt.plot(left_padding, 0.0, 'kx', markersize=10.0)
plt.plot(left_padding + len(s), 0.0, 'kx', markersize=10.0)
plt.plot(t, s_used, 'k-')
plt.plot(t[fit_index], min_fit, 'b-')
plt.plot(mini, s_used[mini], 'bo')
plt.suptitle('Iteration %d' % iter)
#take average of max and min splines
z = (max_fit + min_fit) / 2.0
#compute a factor used to dampen the subtraction of the mean spline; Rato et. al 2008, sec 3.2.3
alpha, palpha = pearsonr(imf, z)
alpha = min(alpha, 1e-2)
#subtract off average of the two splines
d = imf - alpha * z
#set the IMF to the residual for next iteration
imf = d
#check for IMF S-stoppage criteria
mini, maxi = find_extrema(imf)
num_extrema = np.roll(num_extrema, -1, axis=0)
num_extrema[-1, :] = [len(mini), len(maxi)]
if iter >= self.sift_stoppage_S:
num_extrema_change = np.diff(num_extrema, axis=0)
de = np.abs(num_extrema[-1, 0] - num_extrema[-1, 1])
if np.abs(num_extrema_change).sum() == 0 and de < 2 and np.abs(
imf.mean()) < self.sift_mean_tol:
stop = True
if iter > self.sift_max_iter:
stop = True
print 'Iter %d: len(mini)=%d, len(maxi=%d), imf.mean()=%0.6f, alpha=%0.2f' % (
iter, len(mini), len(maxi), imf.mean(), alpha)
#print 'num_extrema=',num_extrema
iter += 1
return imf
def c_correlateX(a,
v,
returnx=False,
returnav=False,
s=0,
xran=None,
coarse=False,
interp='spl'):
'''
:param a:
:param v: a and v can be a dict in following format {'x':[],'y':[]}. The length of a and v can be different.
:param returnx:
:return:
'''
from scipy.interpolate import splev, splrep
import numpy.ma as ma
if isinstance(a, dict):
max_a = np.nanmax(a['x'])
min_a = np.nanmin(a['x'])
max_v = np.nanmax(v['x'])
min_v = np.nanmin(v['x'])
max_ = min(max_a, max_v)
min_ = max(min_a, min_v)
if not max_ > min_:
print('the x ranges of a and v have no overlap.')
return None
if xran is not None:
max_ = min(max_, xran[1])
min_ = max(min_, xran[0])
a_x = ma.masked_outside(a['x'].copy(), min_, max_)
if isinstance(a['y'], np.ma.core.MaskedArray):
a_y = ma.masked_array(a['y'].copy(), a['y'].mask | a_x.mask)
a_x = ma.masked_array(a_x, a_y.mask)
else:
a_y = ma.masked_array(a['y'].copy(), a_x.mask)
v_x = ma.masked_outside(v['x'].copy(), min_, max_)
if isinstance(v['y'], np.ma.core.MaskedArray):
v_y = ma.masked_array(v['y'].copy(), v['y'].mask | v_x.mask)
v_x = ma.masked_array(v_x, v_y.mask)
else:
v_y = ma.masked_array(v['y'].copy(), v_x.mask)
dx_a = np.abs(np.nanmean(np.diff(a_x)))
dx_v = np.abs(np.nanmean(np.diff(v_x)))
if coarse:
if dx_a < dx_v:
icase = 0
elif dx_a >= dx_v:
icase = 1
else:
if dx_a >= dx_v:
icase = 0
elif dx_a < dx_v:
icase = 1
if icase == 0:
v_ = v_y.compressed()
x_ = v_x.compressed()
if interp == 'spl':
tck = splrep(a_x.compressed(), a_y.compressed(), s=s)
ys = splev(x_, tck)
else:
ys = np.interp(x_, a_x.compressed(), a_y.compressed())
a_ = ys
else:
a_ = a_y.compressed()
x_ = a_x.compressed()
if interp == 'spl':
tck = splrep(v_x.compressed(), v_y.compressed(), s=s)
ys = splev(x_, tck)
else:
ys = np.interp(x_, v_x.compressed(), v_y.compressed())
v_ = ys
else:
a_ = a.copy()
v_ = v.copy()
x_ = None
a_ = (a_ - np.nanmean(a_)) / (np.nanstd(a_) * len(a_))
v_ = (v_ - np.nanmean(v_)) / np.nanstd(v_)
print(a_.shape, v_.shape, x_.shape)
if returnx:
if x_ is None:
return [
np.arange(len(a_)) - np.floor(len(a_) / 2.0),
np.correlate(a_, v_, mode='same')
]
else:
return [(np.arange(len(a_)) - np.floor(len(a_) / 2.0)) *
np.nanmean(np.diff(x_)),
np.correlate(a_, v_, mode='same'), x_, a_, v_]
else:
return np.correlate(a_, v_, mode='same')
def port_opt_theory():
pdb.set_trace()
rets = port_opt_data()
noa = len(rets.columns)
print(rets.mean() * 252)
print(rets.cov() * 252)
weights = np.random.random(noa)
weights /= np.sum(weights)
print(weights)
print(np.sum(rets.mean() * weights) * 252)
# expected portfolio variance
print(np.dot(weights.T, np.dot(rets.cov() * 252, weights)))
# expected portfolio standard deviation/volatility
print(np.sqrt(np.dot(weights.T, np.dot(rets.cov() * 252, weights))))
prets = []
pvols = []
for p in range (250):
weights = np.random.random(noa)
weights /= np.sum(weights)
prets.append(np.sum(rets.mean() * weights) * 252)
pvols.append(np.sqrt(np.dot(weights.T,
np.dot(rets.cov() * 252, weights))))
prets = np.array(prets)
pvols = np.array(pvols)
plt.figure(figsize=(8, 4))
plt.scatter(pvols, prets, c=prets / pvols, marker='o')
plt.grid(True)
plt.xlabel('expected volatility')
plt.ylabel('expected return')
# plt.colorbar(label='Sharpe ratio')
plt.savefig(PATH + 'port_opt1.png', dpi=300)
plt.close()
cons = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
bnds = tuple((0, 1) for x in range(noa))
print(noa * [1. / noa,])
opts = timeme(sco.minimize)(min_func_sharpe, noa * [1. / noa,], method='SLSQP',
bounds=bnds, constraints=cons)
print(opts)
print(opts['x'].round(3))
print(statistics(opts['x']).round(3))
optv = timeme(sco.minimize)(min_func_variance, noa * [1. / noa,], method='SLSQP',
bounds=bnds, constraints=cons)
print(optv)
print(optv['x'].round(3))
print(statistics(optv['x']).round(3))
cons = ({'type': 'eq', 'fun': lambda x: statistics(x)[0] - tret},
{'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
bnds = tuple((0, 1) for x in weights)
# Efficient Frontier
# trets = np.linspace(0.0, 0.25, 50)
trets = np.linspace(0.0, 0.25, 4)
tvols = []
for tret in trets:
cons = ({'type': 'eq', 'fun': lambda x: statistics(x)[0] - tret},
{'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
res = timeme(sco.minimize)(min_func_port, noa * [1. / noa,], method='SLSQP',
bounds=bnds, constraints=cons)
tvols.append(res['fun'])
tvols = np.array(tvols)
plt.figure(figsize=(8, 4))
plt.scatter(pvols, prets,
c=prets / pvols, marker='o')
# random portfolio composition
plt.scatter(tvols, trets,
c=trets / tvols, marker='x')
# efficient frontier
plt.plot(statistics(opts['x'])[1], statistics(opts['x'])[0],
'r*', markersize=15.0)
# portfolio with highest Sharpe ratio
plt.plot(statistics(optv['x'])[1], statistics(optv['x'])[0],
'y*', markersize=15.0)
# minimum variance portfolio
plt.grid(True)
plt.xlabel('expected volatility')
plt.ylabel('expected return')
# plt.colorbar(label='Sharpe ratio')
plt.savefig(PATH + 'port_opt_efficient_frontier.png', dpi=300)
plt.close()
ind = np.argmin(tvols)
evols = tvols[ind:]
erets = trets[ind:]
tck = sci.splrep(evols, erets)
def f(x):
''' Efficient frontier function (splines approximation). '''
return sci.splev(x, tck, der=0)
def df(x):
''' First derivative of efficient frontier function. '''
return sci.splev(x, tck, der=1)
def equations(p, rf=0.01):
eq1 = rf - p[0]
eq2 = rf + p[1] * p[2] - f(p[2])
eq3 = p[1] - df(p[2])
return eq1, eq2, eq3
opt = sco.fsolve(equations, [0.01, 0.5, 0.15])
print(opt)
print(np.round(equations(opt), 6))
plt.figure(figsize=(8, 4))
plt.scatter(pvols, prets,
c=(prets - 0.01) / pvols, marker='o')
# random portfolio composition
plt.plot(evols, erets, 'g', lw=4.0)
# efficient frontier
cx = np.linspace(0.0, 0.3)
plt.plot(cx, opt[0] + opt[1] * cx, lw=1.5)
# capital market line
plt.plot(opt[2], f(opt[2]), 'r*', markersize=15.0)
plt.grid(True)
plt.axhline(0, color='k', ls='--', lw=2.0)
plt.axvline(0, color='k', ls='--', lw=2.0)
plt.xlabel('expected volatility')
plt.ylabel('expected return')
# plt.colorbar(label='Sharpe ratio')
plt.savefig(PATH + 'port_opt_capital_market_line.png', dpi=300)
plt.close()
cons = ({'type': 'eq', 'fun': lambda x: statistics(x)[0] - f(opt[2])},
{'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
res = timeme(sco.minimize)(min_func_port, noa * [1. / noa,], method='SLSQP',
bounds=bnds, constraints=cons)
print(res['x'].round(3))
})
results = sco.minimize(get_EF,
init_guess,
method='SLSQP',
bounds=boundary_new,
constraints=cons)
tgstdv.append(results['fun'])
tgstdv = np.array(tgstdv)
''' Find CML using CAPM with risk-free rate being 5%'''
#For the spline interpolation, only consider portfolios under the EF
i = np.argmin(tgstdv) #return indices of the min values along an axis
pfbystdv = tgstdv[i:]
pfbyrtn = tgrtns[i:]
tck = sci.splrep(pfbyrtn, pfbystdv) #sci.splrep(x,y,...) where y=f(x)
def func(x):
'''Spline approximation for the EF'''
return sci.splev(x, tck, der=0)
def firstder(x):
return sci.splev(x, tck, der=1)
def get_CAPM(param, rf=0.05):
capm_1 = rf - param[0]
capm_2 = rf + param[1] * param[2] - func(param[2])
capm_3 = param[1] - firstder(param[2])
k_t = k_c + k_i
line_attenuation = attenuation(f_d, device.data_file,
'drive_attenuation') - 3
if 'powers' in list(hdf5_file[date][time]['LIN'].keys()):
log_powers = np.asarray(hdf5_file[date][time]['LIN'].get('powers'))
elif 'powers_swept' in list(hdf5_file[date][time]['LIN'].keys()):
log_powers = np.asarray(
hdf5_file[date][time]['LIN'].get('powers_swept'))
log_powers = log_powers + line_attenuation
powers = dBm_to_Watts(log_powers)
stark_shift = f_0 - f_0[0]
nbar = 1 / (2 * np.pi * h) * powers * k_c[0] / f_0[0] * (
(f_d / f_0[0])**2) / ((f_d - f_0[0])**2 + (k_t[0] / 2)**2 *
((2 * f_d / (f_0[0] + f_d))**2))
tck = interpolate.splrep(nbar, stark_shift, s=0)
f = Flux(current, device.a, device.b)
fudge_factor = 2.3
g3_ = device.g3_distributed(f) * fudge_factor
g4_ = device.g4_distributed(f)
freq_a = f_0[0]
kappa = k_c[0]
kappa_t = k_t[0]
kappa_c = k_c[0]
n_crit = max(nbar)
n_crit = 20000
nbar_pump_sweep = np.linspace(0, n_crit, 5000)
pump_freqs = np.linspace(2 * freq_a - 1.2e9, 2 * freq_a + 1.2e9, 400)
gains = np.zeros((len(pump_freqs), 5000))
def interpolare(y, x):
fct = interpolate.splrep(x,y) #se creeaza curba de interpolare
new_x = np.arange(x[0],x[0]+2000, 4) # pastram 2000 de secunde / 4 secunde - 500 mom timp
return interpolate.splev(x, fct) #se iau noile valori in functie de curba
def odepsi_m(E, r, U, m):
chi_u = np.zeros((len(r), len(E)))
chi_d = np.zeros(np.shape(chi_u))
chi_u[0, :], chi_d[0, :] = psireg(r[0], E - U[0], m)
nchi = np.abs(chi_u[0, :]) + np.abs(chi_d[0, :]) # this does not involve
# squares of small numbers
np.sqrt(chi_u[0, :]**2 + chi_d[0, :]**2) # unlike prev version
chi_u[0, :] /= nchi
chi_d[0, :] /= nchi
if m >= 0:
Ku = 0
Kd = -1.0 - 2.0 * m
mu = m
else:
mu = -m - 1
Ku = 1.0 + 2.0 * m
Kd = 0
#
# Right-hand side of the ODE: chi'(r) = rhs(r)
#
def rhs(chi_u, chi_d, r, U):
f_u = Ku / r * chi_u - (E - U) * chi_d
f_d = (E - U) * chi_u + Kd / r * chi_d
#f_u = (m-mu)/r * chi_u - (E - U)*chi_d
#f_d = (E - U)*chi_u - (1 + mu + m)/r * chi_d
return f_u, f_d
Us = interpolate.splrep(r, U)
#
# RK4 fourth order method
#
def rk4step(chi_u, chi_d, r_p, r_n, h):
r1 = r_p
r2 = r_p + 0.5 * h
r3 = r2
r4 = r_n
#rs = np.array([r1, r2, r3, r4])
Ui = interpolate.splev(np.array([r1, r2, r3, r4]), Us)
U1 = Ui[0]
U2 = Ui[1]
U3 = Ui[2]
U4 = Ui[3]
k1u, k1d = rhs(chi_u, chi_d, r1, U1)
k2u, k2d = rhs(chi_u + k1u * 0.5 * h, chi_d + 0.5 * k1d * h, r2, U2)
k3u, k3d = rhs(chi_u + k2u * 0.5 * h, chi_d + 0.5 * k2d * h, r3, U3)
k4u, k4d = rhs(chi_u + k3u * h, chi_d + k3d * h, r4, U4)
chi_un = chi_u + h * (k1u + 2 * k2u + 2 * k3u + k4u) / 6.0
chi_dn = chi_d + h * (k1d + 2 * k2d + 2 * k3d + k4d) / 6.0
return chi_un, chi_dn
for i in range(1, len(r)):
chi_un, chi_dn = chi_u[i - 1, :], chi_d[i - 1, :]
h = r[i] - r[i - 1]
dxi = max(abs(E)) * h
# dxi is the phase change over this grid step
# We split the step into smaller sub-steps if dxi
# is too large
dxi0 = 0.1
n_steps = int(dxi / dxi0) + 1
dr = h / n_steps
# Go over sub-steps
for i_step in range(n_steps):
r_p = r[i - 1] + i_step * dr
r_n = r[i - 1] + (i_step + 1) * dr
chi_un, chi_dn = rk4step(chi_un, chi_dn, r_p, r_n, dr)
chi_u[i, :], chi_d[i, :] = chi_un, chi_dn
uu, ud = psireg(r[-1], E, m)
vu, vd = psising(r[-1], E, m)
D = uu * vd - vu * ud
A = (chi_u[-1, :] * vd - chi_d[-1, :] * vu) / D
B = (chi_d[-1, :] * uu - chi_u[-1, :] * ud) / D
r_mu = (r / r[-1])**(mu)
#
# The goal of the crazy expression below is to multiply
# chi by the corresponding values of r^mu. In numpy, multiplying
# a matrix chi(r, E) by vector r would not work: we have to
# transpose the matrix first.
#
psi_u = (r_mu * chi_u.transpose()).transpose()
psi_d = (r_mu * chi_d.transpose()).transpose()
psi_u /= np.sqrt(A**2 + B**2)
psi_d /= np.sqrt(A**2 + B**2)
return psi_u, psi_d
def fit_subsamplefof_mean():
parser = argparse.ArgumentParser(description='This is the MCMC code to get the fitting parameters using Zvonimir model, made by Zhejie Ding.')
parser.add_argument('-rec_id', "--rec_id", help='The id of reconstruction, either 0 or 1.', required=True) #0: pre-reconstruct; 1: post-reconstruct
args = parser.parse_args()
rec_id = int(args.rec_id)
print("rec_id: ", rec_id)
N_walkers = 200
N_walkersteps = 20000
space_id = 1 # in redshift space
print("N_walkers: ", N_walkers, "N_walkersteps: ", N_walkersteps, "\n")
# 0: parameter fixed, 1: parameter free.
params_indices = [1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1] # b0 needs to be fitted. For this case, make sure \Sigma_0,2,4 positive, which should be set in mcmc_routine.
##params_indices = [0, 1, 0, 0, 1, 1] # For this case, make sure \alpha_1 = \alpha_2 in the function lnlike(..) and set sigma_xy, sigma_z equal to Sigma_z.
print("params_indices: ", params_indices)
# simulation run name
N_dataset = 20
N_mu_bin = 100
#N_skip_header = 11
#N_skip_footer = 31977
Omega_m = 0.3075
G_0 = growth_factor(0.0, Omega_m) # G_0 at z=0, normalization factor
Volume = 1380.0**3.0 # the volume of simulation box
sim_z=['0', '0.6', '1.0']
sim_seed = [0, 9]
sim_wig = ['NW', 'WG']
sim_a = ['1.0000', '0.6250', '0.5000']
sim_space = ['r', 's'] # r for real space; s for redshift space
rec_dirs = ['DD', 'ALL'] # "ALL" folder stores P(k, \mu) after reconstruction process, while DD is before reconstruction.
rec_fprefix = ['', 'R']
mcut_Npar_list = [[37, 149, 516, 1524, 3830],
[35, 123, 374, 962, 2105],
[34, 103, 290, 681, 1390]]
N_masscut = np.size(mcut_Npar_list, axis=1)
# Sigma_sm = sqrt(2.* Sig_RR) in post-reconstruction case, for pre-reconstruction, we don't use sub_Sigma_RR.
Sigma_RR_list = [[37, 48.5, 65.5, 84.2, 110],
[33, 38, 48.5, 63.5, 91.5],
[31, 38, 49, 65, 86]]
sub_Sigma_RR = 50.0 # note from Hee-Jong's recording
inputf = '../Zvonimir_data/planck_camb_56106182_matterpower_smooth_z0.dat'
k_smooth, Pk_smooth = np.loadtxt(inputf, dtype='f8', comments='#', unpack=True)
tck_Pk_sm = interpolate.splrep(k_smooth, Pk_smooth)
inputf = '../Zvonimir_data/planck_camb_56106182_matterpower_z0.dat'
k_wiggle, Pk_wiggle = np.loadtxt(inputf, dtype='f8', comments='#', unpack=True)
tck_Pk_linw = interpolate.splrep(k_wiggle, Pk_wiggle)
# firstly, read one file and get k bins we want for the fitting range
dir0='/Users/ding/Documents/playground/WiggleNowiggle/subsample_FoF_data_HS/Pk_obs_2d_wnw_mean_DD_ksorted_mu_masscut/'
inputf = dir0 +'fof_kaver.wnw_diff_a_0.6250_mcut35_fraction0.126.dat'
k_p, mu_p = np.loadtxt(inputf, dtype='f8', comments='#', delimiter=' ', usecols=(0,1), unpack=True)
#print(k_p, mu_p)
N_fitbin = len(k_p)
#print('# of (k, mu) bins: ', N_fitbin)
# for output parameters fitted
odir = './params_{}_wig-now_b_bscale_fitted_mean_dset/'.format(rec_dirs[rec_id])
if not os.path.exists(odir):
os.makedirs(odir)
alpha_1, alpha_2, sigma_0, sigma_2, sigma_4, f, b_0, b_scale0, b_scale2, b_scale4 = 1.0, 1.0, 8.0, 8.0, 8.0, 0.2, 1.0, 0.0, 0.0, 0.0
all_names = "alpha_1", "alpha_2", "sigma_0", "sigma_2", "sigma_4", "sigma_sm", "f", "b_0", "b_scale0", "b_scale2", "b_scale4" # the same order for params_indices
all_temperature = 0.01, 0.01, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 1.0, 1.0, 1.0
pool = MPIPool(loadbalance=True)
for z_id in xrange(1):
norm_gf = growth_factor(float(sim_z[z_id]), Omega_m)/G_0
# for mcut_id in xrange(N_masscut):
# np.random.seed()
# sigma_sm = (float(Sigma_RR_list[z_id][mcut_id])*2.0)**0.5
# all_params = alpha_1, alpha_2, sigma_0, sigma_2, sigma_4, sigma_sm, f, b_0, b_scale0, b_scale2, b_scale4
# N_params, theta, fix_params, params_T, params_name = set_params(all_params, params_indices, all_names, all_temperature)
#
# ifile_Pk = './run2_3_Pk_obs_2d_wnw_mean_{}_ksorted_mu_masscut/{}kave{}.wig_minus_now_mean_fof_a_{}_mcut{}.dat'.format(rec_dirs[rec_id], rec_fprefix[rec_id], sim_space[space_id], sim_a[z_id], mcut_Npar_list[z_id][mcut_id])
# print(ifile_Pk)
# Pk_wnw_diff_obs = np.loadtxt(ifile_Pk, dtype='f4', comments='#', usecols=(2,)) # be careful that there are k, \mu, P(k, \mu) columns.
#
# ifile_Cov_Pk = './run2_3_Cov_Pk_obs_2d_wnw_{}_ksorted_mu_masscut/{}kave{}.wig_minus_now_mean_fof_a_{}_mcut{}.dat'.format(rec_dirs[rec_id], rec_fprefix[rec_id], sim_space[space_id], sim_a[z_id], mcut_Npar_list[z_id][mcut_id])
# Cov_Pk_wnw = np.loadtxt(ifile_Cov_Pk, dtype='f4', comments='#')
# ivar_Pk_wnow = N_dataset/np.diag(Cov_Pk_wnw) # the mean sigma error
#
# params_mcmc = mcmc_routine(N_params, N_walkers, N_walkersteps, theta, params_T, params_indices, fix_params, k_p, mu_p, Pk_wnw_diff_obs, ivar_Pk_wnow, tck_Pk_linw, tck_Pk_sm, norm_gf, params_name, pool)
#
# chi_square = chi2(params_mcmc[:, 0], params_indices, fix_params, k_p, mu_p, Pk_wnw_diff_obs, ivar_Pk_wnow, tck_Pk_linw, tck_Pk_sm, norm_gf)
# reduced_chi2 = chi_square/(N_fitbin-N_params)
# print("Reduced chi2: {}\n".format(reduced_chi2))
# # output parameters into a file
# ofile_params = odir + 'ZV_fof_{}kave{}.wnw_diff_a_{}_mcut{}_params{}_Sigma_sm{}.dat'.format(rec_fprefix[rec_id], sim_space[space_id], sim_a[z_id], mcut_Npar_list[z_id][mcut_id], ''.join(map(str, params_indices)), round(sigma_sm, 3))
# write_params(ofile_params, params_mcmc, params_name, reduced_chi2)
np.random.seed()
sigma_sm = 10.0 # for all redshifts, it's the same value.
all_params = alpha_1, alpha_2, sigma_0, sigma_2, sigma_4, sigma_sm, f, b_0, b_scale0, b_scale2, b_scale4
N_params, theta, fix_params, params_T, params_name = set_params(all_params, params_indices, all_names, all_temperature)
# Fit for DM power spectrum
ifile_Pk = './run2_3_sub_Pk_2d_wnw_mean_{}_ksorted_mu/{}kave{}.wig_minus_now_mean_sub_a_{}.dat'.format(rec_dirs[rec_id], rec_fprefix[rec_id], sim_space[space_id], sim_a[z_id])
Pk_wnw_diff_true = np.loadtxt(ifile_Pk, dtype='f4', comments='#', usecols=(2,)) # be careful that there are k, \mu, P(k, \mu) columns.
print(ifile_Pk)
ifile_Cov_Pk = './run2_3_sub_Cov_Pk_2d_wnw_{}_ksorted_mu/{}kave{}.wig_minus_now_mean_sub_a_{}.dat'.format(rec_dirs[rec_id], rec_fprefix[rec_id], sim_space[space_id], sim_a[z_id])
Cov_Pk_wnw = np.loadtxt(ifile_Cov_Pk, dtype='f4', comments='#')
ivar_Pk_wnow = N_dataset/np.diag(Cov_Pk_wnw) # the mean sigma error
params_mcmc = mcmc_routine(N_params, N_walkers, N_walkersteps, theta, params_T, params_indices, fix_params, k_p, mu_p, Pk_wnw_diff_true, ivar_Pk_wnow, tck_Pk_linw, tck_Pk_sm, norm_gf, params_name, pool)
chi_square = chi2(params_mcmc[:, 0], params_indices, fix_params, k_p, mu_p, Pk_wnw_diff_true, ivar_Pk_wnow, tck_Pk_linw, tck_Pk_sm, norm_gf)
reduced_chi2 = chi_square/(N_fitbin-N_params)
print('Reduced chi2: {}\n'.format(reduced_chi2))
ofile_params = odir + 'ZV_sub_{}kave{}.wnw_diff_a_{}_params{}_Sigma_sm{}.dat'.format(rec_fprefix[rec_id], sim_space[space_id], sim_a[z_id], ''.join(map(str, params_indices)), round(sigma_sm, 3))
write_params(ofile_params, params_mcmc, params_name, reduced_chi2)
pool.close()
def thermal_hall_with_hopping():
plt.ion()
fig, axes = plt.subplots(nrows=1, ncols=3)
fig.subplots_adjust(left=0.05,
right=0.98,
top=0.98,
bottom=0.16,
hspace=0.2,
wspace=0.25)
# phase diagram
ax = axes[0]
ts = np.array([
0.2445, 0.2600, 0.2700, 0.2732, 0.2770, 0.2790, 0.2800, 0.2850, 0.2900,
0.2950, 0.3000, 0.3080, 0.3100, 0.3155, 0.3200, 0.3250, 0.3300, 0.3350,
0.3400, 0.3450, 0.3495
])
us = np.array([
0.0000, 0.2825, 0.4285, 0.4705, 0.5195, 0.5415, 0.5515, 0.5975, 0.6375,
0.6695, 0.6945, 0.7075, 0.7065, 0.6945, 0.6775, 0.6505, 0.6135, 0.5335,
0.3545, 0.1665, 0.0000
])
X = np.linspace(ts.min(), ts.max(), 201)
Y = itp.splev(X, itp.splrep(ts, us, k=3), der=0)
ax.plot(X, Y, lw=2, color='blue', zorder=1)
ts = np.array([0.2732, 0.2800, 0.2850, 0.2900, 0.2950, 0.3000, 0.3080])
us = np.array([0.4705, 0.3835, 0.3215, 0.2615, 0.2005, 0.1315, 0.0000])
X = np.linspace(ts.min(), ts.max(), 201)
Y = itp.splev(X, itp.splrep(ts, us, k=3), der=0)
ax.plot(X, Y, lw=2, color='blue', zorder=1)
ts = np.array([0.3080, 0.3100, 0.3155, 0.3200, 0.3250, 0.3300, 0.3350])
us = np.array([0.0000, 0.0235, 0.1325, 0.2545, 0.3585, 0.4605, 0.5335])
X = np.linspace(ts.min(), ts.max(), 201)
Y = itp.splev(X, itp.splrep(ts, us, k=3), der=0)
ax.plot(X, Y, lw=2, color='blue', zorder=1)
ax.plot([0.29, 0.32], [0.0, 0.0],
ls='solid',
lw=3,
color='green',
zorder=0,
alpha=0.6,
clip_on=False)
ax.plot([0.29, 0.32], [0.1, 0.1],
ls='solid',
lw=3,
color='red',
zorder=0,
alpha=0.6)
ax.minorticks_on()
ax.set_xlim(0.24, 0.36)
ax.set_ylim(0.00, 0.75)
ax.set_xticks(np.linspace(0.24, 0.36, 7))
ax.set_xticklabels(['0.24', '', '0.28', '', '0.32', '', '0.36'])
ax.set_yticks(np.linspace(0.0, 0.7, 8))
ax.set_yticklabels(['0', '', '0.2', '', '0.4', '', '0.6', ''])
for tick in ax.get_xticklabels():
tick.set_fontsize(9)
for tick in ax.get_yticklabels():
tick.set_fontsize(9)
ax.set_xlabel("$t^\prime/t$", fontdict={'fontsize': 10})
ax.set_ylabel("$\Delta U/t$", fontdict={'fontsize': 10})
ax.text(0.26,
0.53,
"NFM",
fontsize=9,
color='black',
ha='center',
va='center')
ax.text(0.305,
0.43,
"FM",
fontsize=9,
color='black',
ha='center',
va='center')
ax.text(0.305,
0.31,
"$(C=0)$",
fontsize=9,
color='black',
ha='center',
va='center')
ax.text(0.275,
0.2,
"TFM$^+$",
fontsize=9,
color='black',
ha='center',
va='center')
ax.text(0.275,
0.1,
"$(C=+1)$",
fontsize=9,
color='black',
ha='center',
va='center')
ax.text(0.3305,
0.2,
"TFM$^-$",
fontsize=9,
color='black',
ha='center',
va='center')
ax.text(0.3305,
0.1,
"$(C=-1)$",
fontsize=9,
color='black',
ha='center',
va='center')
# line 1
ax = axes[1]
name = '%s/HCI_H2(1P-1P)_up_1.0_0.656_1.2_1.2_FBFM_THP30(1.0,1.0)_0.08.dat' % directory
data = np.loadtxt(name)
ax.plot(data[:, 0], data[:, 1] / 0.08, lw=2, color='green')
ax.text(0.300,
-0.20,
"TFM$^+$",
fontsize=9,
color='black',
ha='center',
va='center')
ax.text(0.315,
-0.20,
"TFM$^-$",
fontsize=9,
color='black',
ha='center',
va='center')
ax.minorticks_on()
ax.set_xlim(0.29, 0.32)
ax.set_xticks(np.linspace(0.29, 0.32, 4))
# ax.set_ylim(-0.7, 0.4)
# ax.set_yticks(np.linspace(-0.6, 0.4, 6))
for tick in ax.get_xticklabels():
tick.set_fontsize(9)
for tick in ax.get_yticklabels():
tick.set_fontsize(9)
ax.set_xlabel("$t^\prime/t$", fontdict={'fontsize': 10})
ax.set_ylabel("$\kappa_{xy}/T(-\\frac{k^2_Bt}{K\hbar})$",
fontdict={'fontsize': 10})
# line 2
ax = axes[2]
name = '%s/HCI_H2(1P-1P)_up_1.0_0.656_1.2_1.1_FBFM_THP30(1.0,1.0)_0.08.dat' % directory
data = np.loadtxt(name)
ax.plot(data[:, 0], data[:, 1] / 0.08, lw=2, color='red')
ax.text(0.296,
+0.20,
"TFM$^+$",
fontsize=9,
color='black',
ha='center',
va='center')
ax.text(0.308,
+0.00,
"FM",
fontsize=9,
color='black',
ha='center',
va='center')
ax.text(0.317,
-0.45,
"TFM$^-$",
fontsize=9,
color='black',
ha='center',
va='center')
ax.minorticks_on()
ax.set_xlim(0.29, 0.32)
ax.set_xticks(np.linspace(0.29, 0.32, 4))
# ax.set_ylim(-0.8, 0.6)
# ax.set_yticks(np.linspace(-0.8, 0.6, 8))
for tick in ax.get_xticklabels():
tick.set_fontsize(9)
for tick in ax.get_yticklabels():
tick.set_fontsize(9)
ax.set_xlabel("$t^\prime/t$", fontdict={'fontsize': 10})
ax.set_ylabel("$\kappa_{xy}/T(-\\frac{k^2_Bt}{K\hbar})$",
fontdict={'fontsize': 10})
pdb.set_trace()
plt.savefig('%s/ThermalHallWithHopping.pdf' % destination)
plt.close()
def compute_irs(irs, t):
tck = interpolate.splrep(IRS_TENORS, irs, k=3, s=0)
R = interpolate.splev(t, tck, der=0)
dR = interpolate.splev(t, tck, der=1)
r = dR * t + R
return r, R
def main():
# constants
BIGFONT = 22
MIDFONT = 18
SMFONT = 16
FIG_WIDTH = 12.0
FIG_HEIGHT = 8.0
varname = 'HFX'
nbins = 20
#cases=["ERA5_C2008_add", "ERA5_TY2001_add", "ERA5_WRFROMS_add", "ERA5_WRF_add"]
# cases=["ERA5_C2008_dynlim", "ERA5_TY2001_nolimit", "ERA5_WRFROMS_add", "ERA5_WRF_add"]
#cases=["ERA5_C2008", "ERA5_TY2001", "ERA5_WRFROMS", "ERA5_WRF"]
#cases=[ "ERA5_WRF","ERA5_WRFROMS", "ERA5_TY2001", "ERA5_C2008_dynlim"]
cases = ["WRFROMS", "C2008", "TY2001"]
#line_libs=['ko','ro','bo','go']
#line_libs=['k.','r.','b.','g.']
shade_color_lib = ['salmon', 'cyan', 'lime']
line_lib = ['r', 'b', 'g']
dot_lib = ['*', '^', 's']
#line_libs=['b.','g*','r^','k+']
wrf_root = '/disk/v092.yhuangci/lzhenn/1911-COAWST/'
i_dom = 2
strt_time_str = '201809151800'
end_time_str = '201809160000'
box_R = 80
epsilon = 0.333
rho_air = 1.29
strt_time_obj = datetime.datetime.strptime(strt_time_str, '%Y%m%d%H%M')
end_time_obj = datetime.datetime.strptime(end_time_str, '%Y%m%d%H%M')
fig, ax = plt.subplots()
fig.subplots_adjust(left=0.08,
bottom=0.18,
right=0.99,
top=0.92,
wspace=None,
hspace=None)
for (dot_case, shade_color, line_color,
case) in zip(dot_lib, shade_color_lib, line_lib, cases):
# read track data
tc_info_fn = wrf_root + '/' + case + '/trck.' + case + '.d0' + str(
i_dom)
dateparse = lambda x: datetime.datetime.strptime(x, '%Y%m%d%H0000')
df_tc_info = pd.read_csv(tc_info_fn,
sep='\s+',
parse_dates=True,
index_col='timestamp',
header=0,
date_parser=dateparse)
df_tc_info = df_tc_info[((df_tc_info.index >= strt_time_obj) &
(df_tc_info.index <= end_time_obj))]
print(df_tc_info)
tc_lat = df_tc_info['lat']
tc_lon = df_tc_info['lon']
# read raw input
ds = salem.open_wrf_dataset('/disk/v092.yhuangci/lzhenn/1911-COAWST/' +
case + '/wrfout_d02')
ds = ds.sel(time=slice(strt_time_obj, end_time_obj))
var1 = ds[varname] # heat exch
var2 = ds['U10'] # momentum exch
var3 = ds['U10']
var4 = ds['V10']
varmask = ds['LANDMASK']
var1.values = np.where(varmask.values == 1, np.nan, var1.values)
var2.values = np.where(varmask.values == 1, np.nan, var2.values)
ws = np.sqrt(var3 * var3 + var4 * var4)
idx = get_closest_idx(var1.lat, var1.lon, tc_lat.values, tc_lon.values)
var1_box_comp = box_collect(var1.values, box_R, idx) # nparray inout
var2_box_comp = box_collect(var2.values, box_R, idx) # nparray inout
ratio = var1_box_comp / var2_box_comp
ws_box_comp = box_collect(ws.values, box_R, idx) # nparray inout
ws_box_comp = ws_box_comp[~np.isnan(ws_box_comp)]
var1_box_comp = var1_box_comp[~np.isnan(var1_box_comp)]
# get bins
bin_means, bin_edges, binnumber = stats.binned_statistic(
ws_box_comp.flatten(),
var1_box_comp.flatten(),
statistic='mean',
bins=nbins)
bin_counts, bin_edges, binnumber = stats.binned_statistic(
ws_box_comp.flatten(),
var1_box_comp.flatten(),
statistic='count',
bins=nbins)
lh_heat = bin_means * bin_counts * 3600 * 27000 * 27000 / 10e15 # 1e15 J
x_pos = (bin_edges[0:-1] + bin_edges[1:]) / 2
tck = interpolate.splrep(x_pos, lh_heat, s=0)
x_spline = np.linspace(x_pos.min(), x_pos.max(), 300)
lh_heat_smooth = interpolate.splev(x_spline, tck, der=0)
# scatter
#ax.plot(x_pos, lh_heat, linewidth=0.0, color=line_color, marker=dot_case, markersize=8)
ax.plot(x_spline,
lh_heat_smooth,
label=case,
linewidth=2.,
color=line_color)
ax.fill_between(x_spline,
0,
lh_heat_smooth,
alpha=0.2,
color=shade_color)
plt.legend(loc='best', fontsize=SMFONT)
plt.xlabel('10m WindSpeed (m/s)', fontsize=SMFONT)
plt.ylabel(varname + ' (10^15 J)', fontsize=SMFONT)
plt.xticks(fontsize=SMFONT)
plt.yticks(fontsize=SMFONT)
plt.title('Accum. ' + varname + ' - 10m WindSpeed', fontsize=BIGFONT)
fig.set_size_inches(FIG_WIDTH, FIG_HEIGHT)
fig.savefig('../fig/acc_' + varname + '.png')
def TDI_signal(self, tvec):
### Getting parameters: TODO: FIX THIS, HARDCODED
self.z = 1. #!!!! HARDCODED TODO
distance = (Cosmology.DL(self.z, 0.0)[0]) * 1.e6 # in pc
#?| Defone the constants that we are going to be using
P_SI = LC.pc
MTSUN_SI = LC.MTsun
C_SI = LC.clight
AU_SI = LC.ua
year = LC.year
arm = LP.lisaL
#?| Additional parameters
#phic = 2.12 ## FIXME FIXME FIXME
#phic = 1.2
#phic = 2.12
phic = 0.0
Rmin = 6.0 # minimum distance (in M) used to terminate the waveform
M = self.m1 + self.m2
Mt = M * MTSUN_SI
M2 = M * M
eta = self.m1 * self.m2 / M2
DLt = distance * P_SI / C_SI # distance in sec
if (self.m1 < self.m2):
tmp = self.m1
self.m1 = self.m2
self.m2 = tmp
tc = self.Tc
if (self.Tobs < self.Tc):
tc = self.Tobs
# The N-th sample where the model is non-zero
N = (int)(tc / self.dt)
tm = np.arange(N) * self.dt
# Coefficients
fac = eta / (5.0 * Mt)
p0 = -2.0 # -2 fac^(5/8)
p10 = -(3715. / 4032. + 55. / 48. * eta
) # - (3715/4032 + 55/48 eta) fac^(3/8)
p15 = 0.375 # (3/8) fac^(1/4)
p150 = p15 * (4. * np.pi)
# 4 pi (3/8) fac^(1/4)
p20 = -1.0
# - fac^(1/8)
p200 = p20 * (9275495. / 7225344. + 284875. / 129024. * eta +
1855. / 1024. * eta * eta)
# - (9275495/7225344 + 284875/129024 eta + 1855/1024 eta^2) fac^(1/8)
beta = (self.chi1 / 12.0) * (
113.0 * self.m1 * self.m1 / M2 + 75.0 * eta
) + (self.chi2 / 12.0) * (113.0 * self.m2 * self.m2 / M2 + 75.0 * eta)
sigma = (237.0 / 24.0) * eta * self.chi1 * self.chi2
f10 = 743. / 2688. + 11. / 32. * eta
f15 = -3. * (4. * np.pi - beta) / 40.
f20 = 1855099. / 14450688. + 56975. / 258048. * eta + 371. / 2048. * eta * eta - 3. / 64. * sigma
#Orbital motion
AU = AU_SI / C_SI
Phi_LISA = 2.0 * np.pi * tm / year
R = np.zeros((len(tm), 3))
R[:, 0] = AU * np.cos(Phi_LISA)
R[:, 1] = AU * np.sin(Phi_LISA)
thS = 0.5 * np.pi - self.bet
phS = self.lam
n = np.array([
np.cos(phS) * np.sin(thS),
np.sin(phS) * np.sin(thS),
np.cos(thS)
])
nR = np.dot(R, n)
tmk = tm + nR
L = arm / C_SI
tmk2L = tmk - 2.0 * L
N = len(tvec) - 1
Mom = np.zeros(N)
phase = np.zeros(N)
ampl = np.zeros(N)
ampl0 = 2.0 * Mt * eta / DLt
#print "Amplitude:", ampl0, Mt, eta, 1.0/DLt
tau = fac * (tc - tmk)
tau = np.clip(tau, 0.0001, 1. * year)
Mom = (np.power(tau, (-3. / 8.)) + f10 * np.power(tau, (-5. / 8.)) +
f15 * np.power(tau,
(-3. / 4.)) + f20 * np.power(tau,
(-7. / 8.))) / 8.
phase_tk = (p0 * np.power(tau, (0.625)) + p10 * np.power(tau,
(0.375)) +
(p150 - p15 * beta) * np.power(tau, (0.25)) +
(p200 + 15.0 * sigma / 32.) * np.power(tau, (0.125))) / eta
#tau0 = fac*(tc-tm)
#phase = (p0*tau0**(0.625) + p10*tau0**(0.375) + (p150 - p15*beta)*tau0**(0.25) +
# (p200 + 15.0*sigma/32.)*tau0**(0.125))/eta
tau2L = fac * (tc - tmk2L)
tau2L = np.clip(tau2L, 0.0001, 1. * year)
phase_tk2L = (p0 * np.power(tau2L,
(0.625)) + p10 * np.power(tau2L, (0.375)) +
(p150 - p15 * beta) * np.power(tau2L, (0.25)) +
(p200 + 15.0 * sigma / 32.) * np.power(tau2L,
(0.125))) / eta
ampl = ampl0 * np.power(Mom, (2. / 3.))
# let's find where we need to terminate the waveform
Mom_max = np.power(7.0, (-1.5))
Mom_max6 = np.power(6.0, (-1.5))
if np.max(Mom) < Mom_max:
Mom_max = 0.98 * Mom
#Mom_max = Mom_max6
#i_max = np.argwhere(Mom > Mom_max)[0][0]
#i_max6 = np.argwhere(Mom > Mom_max6)[0][0]
taper = 0.5 * (1.0 + np.tanh(57.0 * (np.power(
(Mom_max), (2. / 3.)) - np.power(Mom, (2. / 3.)))))
test1 = (np.power((Mom_max), (2. / 3.)))
test2 = np.power(Mom, (2. / 3.))
ampl = ampl * taper
om = Mom / Mt
# Antenna pattern
th_d = self.bet + 0.5 * np.pi
lam_d = self.lam + np.pi
### experiment
Nt = (int)(tc / self.dt) # + 1
tm_f = tvec[:Nt]
tck = interpolate.splrep(tm, phase_tk, s=0)
ph_tk = interpolate.splev(tm_f, tck, der=0)
tck = interpolate.splrep(tm, phase_tk2L, s=0)
ph_tk2L = interpolate.splev(tm_f, tck, der=0)
tck = interpolate.splrep(tm, ampl, s=0)
ampl_f = interpolate.splev(tm_f, tck, der=0)
tck = interpolate.splrep(tm, om, s=0)
om_f = interpolate.splev(tm_f, tck, der=0)
ampl = ampl_f
om = om_f
del_phi = 0.5 * (ph_tk - ph_tk2L)
phi_p = 0.5 * (ph_tk + ph_tk2L)
Phi_LISA = 2.0 * np.pi * tm / year
#del_phi = 0.5*(phase_tk - phase_tk2L)
#phi_p = 0.5*(phase_tk + phase_tk2L)
Om_A = 0.0 # for A and Om = -0.5*np.pi for E
Om_E = -0.5 * np.pi # for E
Fp_A = (1.0/32.0)*( 6.0*np.sin(2.0*th_d) *(3.0*np.sin(Phi_LISA + lam_d + Om_A) - np.sin(3.0*Phi_LISA - lam_d + Om_A) ) \
-18.0*np.sqrt(3.0)*np.sin(th_d)*np.sin(th_d)*np.sin(2.0*Phi_LISA+Om_A) - \
np.sqrt(3.0)*(1.0+np.cos(th_d)*np.cos(th_d))*(np.sin(4.0*Phi_LISA-2.0*lam_d+Om_A) + 9.0*np.sin(2.0*lam_d+Om_A)) )
Fc_A = (1.0/16.0)*( np.sqrt(3.0)*np.cos(th_d)*(np.cos(4.0*Phi_LISA - 2.0*lam_d + Om_A)) -\
9.0*np.cos(2.0*lam_d + Om_A) + 6.0*np.sin(th_d)*( np.cos(3.0*Phi_LISA-lam_d + Om_A) + \
3.0*np.cos(Phi_LISA +lam_d + Om_A) ) )
Fp_E = (1.0/32.0)*( 6.0*np.sin(2.0*th_d) *(3.0*np.sin(Phi_LISA + lam_d + Om_E) - np.sin(3.0*Phi_LISA - lam_d + Om_E) ) \
-18.0*np.sqrt(3.0)*np.sin(th_d)*np.sin(th_d)*np.sin(2.0*Phi_LISA+Om_E) - \
np.sqrt(3.0)*(1.0+np.cos(th_d)*np.cos(th_d))*(np.sin(4.0*Phi_LISA-2.0*lam_d+Om_E) + 9.0*np.sin(2.0*lam_d+Om_E)) )
Fc_E = (1.0/16.0)*( np.sqrt(3.0)*np.cos(th_d)*(np.cos(4.0*Phi_LISA - 2.0*lam_d + Om_E)) -\
9.0*np.cos(2.0*lam_d + Om_E) + 6.0*np.sin(th_d)*( np.cos(3.0*Phi_LISA-lam_d + Om_E) + \
3.0*np.cos(Phi_LISA +lam_d + Om_E) ) )
cpsi = np.cos(2.0 * self.psi)
spsi = np.sin(2.0 * self.psi)
hp0 = -(1.0 + np.cos(self.incl) *
np.cos(self.incl)) * ampl # multiply by sin\Phi
hc0 = 2.0 * np.cos(self.incl) * ampl
print('[om] = ', om.shape)
print('[hp0] = ', hp0.shape)
print('[Fp_A] = ', Fp_A.shape)
print('[cpsi] = ', cpsi.shape)
print('[Fc_A] = ', Fc_A.shape)
print('[spsi] = ', spsi.shape)
print('[phi_p] = ', phi_p.shape)
h_A = - 2.0*L*om*np.sin(del_phi)*( hp0*(Fp_A*cpsi - Fc_A*spsi)*np.cos(phi_p+phic) + \
hc0*(Fp_A*spsi + Fc_A*cpsi)*np.sin(phi_p+phic) )
h_E = - 2.0*L*om*np.sin(del_phi)*( hp0*(Fp_E*cpsi - Fc_E*spsi)*np.cos(phi_p+phic) + \
hc0*(Fp_E*spsi + Fc_E*cpsi)*np.sin(phi_p+phic) )
# Zero-pad
A = np.pad(h_A, (0, len(tvec) - len(h_A)), 'constant')
E = np.pad(h_E, (0, len(tvec) - len(h_E)), 'constant')
return A, E
import numpy as np
from scipy.interpolate import splrep, splev
import pylab
filtdir = 'VST_response/'
# optical atmospheric transmission
f = open('paranal_atm_transmission.dat', 'r')
atm_wav, atm_t = np.loadtxt(f, unpack=True)
f.close()
atm_wav *= 10.
atm_spline = splrep(atm_wav, atm_t, k=1)
pylab.plot(atm_wav, atm_t, color='k', label='Atmosphere')
bands = ['u', 'g', 'r', 'i']
colors = ['b', 'c', 'g', 'orange', 'r']
for band, color in zip(bands, colors):
f = open('%s_OmegaCAM.res' % band, 'r')
old_wav, old_t = np.loadtxt(f, unpack=True)
f.close()
f = open(filtdir + '/%s_modified_transmission_data_with_ccd' % band, 'r')
filt_tab = np.loadtxt(f)
f.close()
def make_spline(t,
m,
e_m,
knots=None,
k=1,
s=None,
fitflux=0,
zpt=0,
tmin=None,
tmax=None,
task=-1,
anchor_dist=[5.0, 5.0],
slopes=[None, None]):
'''A wrapper around splrep that makes sure the independent variable is
monotonic and non-repeating. Required arguments: time (t), magnitudes
(m) and errors (e_m). If knots are specified, use them (if task==-1), otherwise,
they are computed from -10 days to 100 days in 10-day increments. k is the
spline order (default 1) and s is the smoothing factor, as per splrep. If fitflux
is nonzero, convert magnitudes to flux (using provided zpt). tmin and tmax should
be set to the limits of the spline.'''
# first, we make sure that t is monotonically increasing with no repeated
# elements
sids = num.argsort(t)
tt = t[sids] #num.take(t, sids)
mm = m[sids] # num.take(m, sids)
ee_m = e_m[sids] #num.take(e_m, sids)
if tmin is None:
tmin = t.min()
if tmax is None:
tmax = t.max()
# here's some Numeric magic. first, find where we have repeating x-values
Nmatrix = num.equal(tt[:, num.newaxis], tt[num.newaxis, :])
#val_matrix = mm[:,num.newaxis]*num.ones((len(mm),len(mm)))
#e_matrix = ee_m[:,num.newaxis]*num.ones((len(mm),len(mm)))
val_matrix = mm[:, num.newaxis] * Nmatrix
e_matrix = ee_m[:, num.newaxis] * Nmatrix
average = sum(val_matrix) / sum(Nmatrix)
e_average = sum(e_matrix) / sum(Nmatrix)
# at this point, average is the original data, but with repeating data points
# replaced with their average. Now, we just pick out the unique x's and
# the first of any repeating points:
gids = num.concatenate([[1], num.greater(tt[1:] - tt[:-1], 0.)])
tt = num.compress(gids, tt)
mm = num.compress(gids, average)
ee_m = num.compress(gids, e_average)
# Now get rid of any data that's outside [tmin,tmax]
gids = num.less_equal(tt, tmax) * num.greater_equal(tt, tmin)
#tt = num.compress(gids,tt)
tt = tt[gids]
#mm = num.compress(gids,mm)
mm = mm[gids]
#ee_m = num.compress(gids,ee_m)
ee_m = ee_m[gids]
ee_m = num.where(num.less(ee_m, 0.001), 0.001, ee_m)
# Next, add some anchors to the data to control the slopes
if anchor_dist[0] > 0 and task != -1:
if slopes[0] is not None:
mm0 = mm[0] - slopes[0] * anchor_dist[0]
else:
mm0 = mm[0] - (mm[1] - mm[0]) / (tt[1] - tt[0]) * anchor_dist[0]
tt = num.concatenate([[tt[0] - anchor_dist[0]], tt])
mm = num.concatenate([[mm0], mm])
ee_m = num.concatenate([[ee_m[0]], ee_m])
if anchor_dist[1] > 0:
if slopes[1] is not None:
mm1 = mm[-1] + slopes[1] * anchor_dist[1]
else:
mm1 = mm[-1] + (mm[-1] - mm[-2]) / (tt[-1] -
tt[-2]) * anchor_dist[1]
tt = num.concatenate([tt, [tt[-1] + anchor_dist[1]]])
mm = num.concatenate([mm, [mm1]])
ee_m = num.concatenate([ee_m, [ee_m[-1]]])
# Now convert to flux if requested:
if fitflux:
mm = num.power(10, -0.4 * (mm - zpt))
ee_m = mm * ee_m / 1.087
if knots is None and task == -1:
# Use the minimal number
knots = tmin + num.arange(2 * k + 3) * (tmax - tmin) / (2 * k + 2)
# Okay, now make the spline representation
tck, fp, ier, msg = splrep(tt,
mm,
1.0 / ee_m,
k=k,
s=s,
t=knots,
task=task,
full_output=1)
return (tck, fp, ier, msg)
def inputData(x, y, x_new, derivate_order=0, k=3):
tck = interpolate.splrep(x, y, s=derivate_order, k=k)
y_new = interpolate.splev(x_new, tck, der=0)
return y_new
# Losses of prestressing due to friction
lssFrict = tendon.getLossFriction(coefFric=mu,
k=k,
sigmaP0_extr1=sigmap0max,
sigmaP0_extr2=0.0)
# Losses of prestressing due to anchorage slip (loss due to friction must be
# previously calculated
lssAnch = tendon.getLossAnchor(Ep=Ep,
anc_slip_extr1=deltaL,
anc_slip_extr2=0.0)
stressAfterLossAnch = tendon.stressAfterLossFriction - lssAnch
'''
#Plot
fig1,ax2d=tendon.plot2D(XaxisValues='X',resultsToPlot=[[stressAfterLossAnch,'r-','Stress after loss due to anchorage slip']])
fig1.show()
'''
areaSigmFric = interpolate.splint(0, tendon.fineScoord[-1], tendon.tckLossFric)
tckLA = interpolate.splrep(tendon.fineScoord, stressAfterLossAnch, k=3)
areaSigmAnc = interpolate.splint(0, tendon.fineScoord[-1], tckLA)
ratio = (areaSigmFric - areaSigmAnc) - Ep * deltaL
import os
from misc_utils import log_messages as lmsg
fname = os.path.basename(__file__)
if (abs(ratio) < 1e-6):
print('test ' + fname + ': ok.')
else:
lmsg.error(fname + ' ERROR.')
import ndinterp
from scipy.interpolate import splrep
Ngal = 1000 # sample size
nv200 = 5
nvorb = 5
v200sigma_rat_grid = np.linspace(0.2, 1., nv200)
vorbv200_rat_grid = np.linspace(0.5, 1.5, nvorb)
vdisp_b_grid = np.zeros((nv200, nvorb))
vdisp_a_grid = np.zeros((nv200, nvorb))
v200sigma_rat_spline = splrep(v200sigma_rat_grid, np.arange(nv200))
vorbv200_rat_spline = splrep(vorbv200_rat_grid, np.arange(nvorb))
axes = {0: v200sigma_rat_spline, 1: vorbv200_rat_spline}
z_0 = 2.
ximin = 0.03
modelname = 'mstar'
imf_coeff = (0.21, 0.26, 0.)
vdisp_coeff = (2.34 + 0.20*(np.log10(3.) - np.log10(1.2)), 0.18)
lmhalos = shmrs.generate_halos(100000, z=2., lmhmax=13.5)
lmstars = shmrs.generate_mstar(lmhalos, z=2., scat=0.18)
selection = lmstars > 10.3
