def __init__(self,filename,path='',**kwargs):
store = pd.HDFStore(filename,'r')
fns = store[path+'/fns']
if '{}/samples'.format(path) in store:
samples = store[path+'/samples']
self.samples = np.array(samples)
minval = fns['vals'].iloc[0]
maxval = fns['vals'].iloc[-1]
pdf = interpolate(fns['vals'],fns['pdf'],s=0,k=1)
#check to see if tabulated CDF is monotonically increasing
d_cdf = fns['cdf'][1:] - fns['cdf'][:-1]
if np.any(d_cdf < 0):
logging.warning('tabulated CDF in {} is not strictly increasing. Recalculating CDF from PDF'.format(filename))
cdf = None #in this case, just recalc cdf from pdf
else:
cdf = interpolate(fns['vals'],fns['cdf'],s=0,k=1)
Distribution.__init__(self,pdf,cdf,minval=minval,maxval=maxval,
**kwargs)
store = pd.HDFStore(filename,'r')
try:
keywords = store.get_storer('{}/fns'.format(path)).attrs.keywords
for kw,val in keywords.iteritems():
setattr(self,kw,val)
except AttributeError:
logging.warning('saved distribution {} does not have keywords or disttype saved; perhaps this distribution was written with an older version.'.format(filename))
store.close()
def __init__(self,samples,bins=10,equibin=True,smooth=0,order=1,**kwargs):
self.samples = samples
if type(bins)==type(10) and equibin:
N = len(samples)//bins
sortsamples = np.sort(samples)
bins = sortsamples[0::N]
if bins[-1] != sortsamples[-1]:
bins = np.concatenate([bins,np.array([sortsamples[-1]])])
hist,bins = np.histogram(samples,bins=bins,density=True)
self.bins = bins
bins = (bins[1:] + bins[:-1])/2.
pdf_initial = interpolate(bins,hist,s=smooth,k=order)
def pdf(x):
x = np.atleast_1d(x)
y = pdf_initial(x)
w = np.where((x < self.bins[0]) | (x > self.bins[-1]))
y[w] = 0
return y
cdf = interpolate(bins,hist.cumsum()/hist.cumsum().max(),s=smooth,
k=order)
if 'maxval' not in kwargs:
kwargs['maxval'] = samples.max()
if 'minval' not in kwargs:
kwargs['minval'] = samples.min()
keywords = {'bins':bins,'smooth':smooth,'order':order}
Distribution.__init__(self,pdf,cdf,keywords=keywords,**kwargs)
def polar_to_cartesian(data, rs, thetas, order = 3):
# Source: http://stackoverflow.com/questions/2164570/reprojecting-polar-to-cartesian-grid
# Set up xy-grid
max_r = rs[-1]
resolution = 2 * len(rad)
xs = np.linspace(-max_r, max_r, resolution)
ys = np.linspace(-max_r, max_r, resolution)
xs_grid, ys_grid = np.meshgrid(xs, ys)
# Interpolate rt-grid
interpolated_rs = interpolate(rs, np.arange(len(rs)), bounds_error = False)
interpolated_thetas = interpolate(thetas, np.arange(len(thetas)), bounds_error = False)
# Match up xy-grid with rt-grid
new_rs = np.sqrt(np.power(xs_grid, 2) + np.power(ys_grid, 2))
new_thetas = np.arctan2(ys_grid, xs_grid)
# Convert from [-pi, pi] to [0, 2 * pi]
new_thetas[new_thetas < 0] = new_thetas[new_thetas < 0] + 2 * np.pi
new_interpolated_rs = interpolated_rs(new_rs.ravel())
new_interpolated_thetas = interpolated_thetas(new_thetas.ravel())
# Fix Bounds (outside of polar image, but inside cartesian image)
new_interpolated_rs[new_rs.ravel() > max(rs)] = len(rs) - 1
new_interpolated_rs[new_rs.ravel() < min(rs)] = 0
cart_data = map_coordinates(data, np.array([new_interpolated_rs, new_interpolated_thetas]), order = order).reshape(new_rs.shape)
return xs_grid, ys_grid, cart_data
def __init__(self,filename,path='',disttype=None,**kwargs):
"""if disttype is 'hist' or 'kde' then samples are required
"""
fns = pd.read_hdf(filename,path+'/fns')
self.disttype = disttype
if disttype in ['hist','kde']:
samples = pd.read_hdf(filename,path+'/samples')
self.samples = np.array(samples)
minval = fns['vals'].iloc[0]
maxval = fns['vals'].iloc[-1]
pdf = interpolate(fns['vals'],fns['pdf'],s=0)
cdf = interpolate(fns['vals'],fns['cdf'],s=0)
Distribution.__init__(self,pdf,cdf,minval=minval,maxval=maxval,
**kwargs)
def __init__(self,samples,bins=10,smooth=0,**kwargs):
self.samples = samples
hist,bins = np.histogram(samples,bins=bins,normed=True)
self.bins = bins
self.hist = hist #debug
bins = (bins[1:] + bins[:-1])/2.
pdf = interpolate(bins,hist,s=smooth)
cdf = interpolate(bins,hist.cumsum()/hist.cumsum().max(),s=smooth)
if 'maxval' not in kwargs:
kwargs['maxval'] = samples.max()
if 'minval' not in kwargs:
kwargs['minval'] = samples.min()
Distribution.__init__(self,pdf,cdf,**kwargs)
def __init__(self,pdf,cdf=None,name='',minval=-np.inf,maxval=np.inf,norm=None,
no_cdf=False,cdf_pts=100):
self.name = name
self.pdf = pdf
self.cdf = cdf
self.minval = minval
self.maxval = maxval
if not hasattr(self,'Ndists'):
self.Ndists = 1
if norm is None:
self.norm = quad(pdf,minval,maxval,full_output=1)[0]
else:
self.norm = norm
if cdf is None and not no_cdf and minval != -np.inf and maxval != np.inf:
pts = np.linspace(minval,maxval,cdf_pts)
pdfgrid = self(pts)
cdfgrid = pdfgrid.cumsum()/pdfgrid.cumsum().max()
cdf_fn = interpolate(pts,cdfgrid,s=0)
def cdf(x):
x = np.atleast_1d(x)
y = np.atleast_1d(cdf_fn(x))
y[np.where(x < self.minval)] = 0
y[np.where(x > self.maxval)] = 1
return y
self.cdf = cdf
def load_distribution(filename,path=''):
fns = pd.read_hdf(filename,path)
store = pd.HDFStore(filename)
if '{}/samples'.format(path) in store:
samples = pd.read_hdf(filename,path+'/samples')
samples = np.array(samples)
minval = fns['vals'].iloc[0]
maxval = fns['vals'].iloc[-1]
pdf = interpolate(fns['vals'],fns['pdf'],s=0)
cdf = interpolate(fns['vals'],fns['cdf'],s=0)
attrs = store.get_storer('{}/fns'.format(path)).attrs
keywords = attrs.keywords
t = attrs.disttype
store.close()
return t.__init__()
def iterate():
global solution, G3, iteration
iteration+=1
psi=interpolate([0.]+psi_range, [G3]+solution.tolist())
new_solution=[]
for i,p in enumerate(psi_range):
new_solution.append(integratus(lambda k:K(k,p)*psi(k),0.,L-dx/2.)[0]+b[i])
solution=np.array(new_solution)
G3=G3_proper()
def _directivity(self, theta, phi):
"""
Custom directivity.
Interpolate the directivity given longitude and latitude vectors.
"""
f = interpolate(self.theta, self.phi, self.r)
return f(theta, phi)
def rescale(factor):
global solution, L
psi=interpolate([0.]+psi_range, [G3]+solution.tolist())
old_L=L
L=L*factor
define_ranges()
new_solution=[]
for p in psi_range:
new_solution.append(integratus(lambda k:K(k,p)*psi(k),0.,old_L-dx/2.)[0]+right_side(p))
solution=np.array(new_solution)
def __init__(self,samples,bins=10,smooth=0,order=1,**kwargs):
self.samples = samples
hist,bins = np.histogram(samples,bins=bins,density=True)
self.bins = bins
bins = (bins[1:] + bins[:-1])/2.
pdf_initial = interpolate(bins,hist,s=smooth,k=order)
def pdf(x):
x = np.atleast_1d(x)
y = pdf_initial(x)
w = np.where((x < bins[0]) | (x > bins[-1]))
y[w] = 0
return y
cdf = interpolate(bins,hist.cumsum()/hist.cumsum().max(),s=smooth,
k=order)
if 'maxval' not in kwargs:
kwargs['maxval'] = samples.max()
if 'minval' not in kwargs:
kwargs['minval'] = samples.min()
Distribution.__init__(self,pdf,cdf,**kwargs)
def cum_draw(df=exo,color='k',mindate=1995,maxdate=2015,ax=None,norm=False,fill=True, kois=False,
alpha=0.2,interp=False,kepler=False,kepsmall=False,label=None,xylabel=(0.1,0.8),
zorder=0):
if ax is None:
fig, ax = plt.subplots(1,1)
else:
fig = ax.figure
dates = np.sort(df.DATE)
ds = np.unique(dates).astype(float)
ns = np.zeros(len(ds))
for i,d in enumerate(ds):
ns[i] = (dates<=d).sum()
if norm:
ns /= ns.max()
ns *= norm
if interp:
dgrid = np.arange(mindate,maxdate,0.1)
fn = interpolate(ds,ns,s=0)
y1 = fn(dgrid)
y2 = -y1
else:
dgrid = ds
y1 = ns
y2 = -ns
#ax.plot(dgrid,y1,color=color)
#ax.plot(dgrid,y2,color=color)
ax.fill_between(dgrid,y1,y2,alpha=alpha,color=color, zorder=zorder)
ax.set_xlim(xmin=mindate,xmax=maxdate)
ax.set_yticks([])
date_ticks = np.arange(mindate,maxdate+1,2)
#for d in date_ticks:
# ax.axvline(d, ls=':', color='k', alpha=0.2)
ax.set_xticks(date_ticks)
ax.tick_params(labelsize=16)
ax.spines["top"].set_visible(False)
ax.spines["bottom"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.spines["left"].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.xaxis.set_tick_params(width=3, length=10)
if label is not None:
label = '%s (%i)' % (label,ns.max())
pl.annotate(label,xy=xylabel,xycoords='axes fraction',fontsize=18,color=color)
return fig
def readens(self, fname):
ens = np.loadtxt(fname).T
self.qv = ens[0]
#Linear
self.xi00lin = ens[1]
xi0lin = ens[2]
xi2lin = ens[3]
self.Xlin = 2 / 3. * (self.xi00lin - xi0lin - xi2lin)
ylinv = 2 * xi2lin
#Since we divide by ylin, check for zeros
mask = (ylinv == 0)
ylinv[mask] = interpolate(self.qv[~mask], ylinv[~mask])(self.qv[mask])
self.Ylin = ylinv
#Useful variables here
self.XYlin = (self.Xlin + self.Ylin)
self.sigma = self.XYlin[-1]
self.yq = (1 * self.Ylin / self.qv)
#Loop
self.xi00loop = ens[4] + ens[5]
xi0loop = ens[6] + ens[7]
xi2loop = ens[8] + ens[9]
self.Xloop = 2 / 3. * (self.xi00loop - xi0loop - xi2loop)
self.Yloop = 2 * xi2loop
self.XYloop = (self.Xloop + self.Yloop)
self.sigmaloop = self.XYloop[-1]
#Loop2
self.xi1loop = ens[10]
self.xi3loop = ens[11]
self.corr = ens[12]
self.zeta = ens[13]
self.chi = ens[14]
self.u10 = ens[15]
self.u30 = ens[16]
self.u11 = ens[17]
self.u20 = ens[18]
self.v10 = ens[19]
self.v12 = ens[20]
self.x10 = ens[21]
self.y10 = ens[22]
self.x20 = ens[23]
self.y20 = ens[24]
def generate_rand_from_spline(pdf, x_grid, xmin, xmax):
pdf_initial = interpolate(x_grid, pdf, s=0, k=1)
xscan = np.linspace(xmin, xmax, 1000)
pdfstep = pdf_initial(xscan)
ymax = max(pdfstep)
i = 0
vals = []
while (i < 1000):
x = np.random.uniform(xmin, xmax)
y = np.random.uniform(0, ymax)
yp = pdf_initial(x)
if (y < yp):
i += 1
vals.append(x)
#print(i,x,y,y_max,p_accept)
return vals
def __init__(self,pdf,cdf=None,name='',minval=-np.inf,maxval=np.inf,norm=None,
no_cdf=False,prior=None,cdf_pts=500):
self.name = name
def newpdf(x):
if prior is None:
return pdf(x)
else:
return prior(x)*pdf(x)
self.lhood = pdf
self.pdf = newpdf
self.cdf = cdf #won't be right if prior given
self.minval = minval
self.maxval = maxval
self.prior = prior
if not hasattr(self,'Ndists'):
self.Ndists = 1
if norm is None:
self.norm = quad(self.pdf,minval,maxval,full_output=1)[0]
else:
self.norm = norm
if (cdf is None and not no_cdf and minval != -np.inf and maxval != np.inf) or prior is not None:
pts = np.linspace(minval,maxval,cdf_pts)
pdfgrid = self(pts)
#fix special case: last value is infinity (i.e. from isotropic prior)
if np.isinf(pdfgrid[-1]):
tip_integral = quad(self,pts[-2],pts[-1])[0]
#print tip_integral
cdfgrid = pdfgrid[:-1].cumsum()/pdfgrid[:-1].cumsum().max() * (1-tip_integral)
cdfgrid = np.concatenate((cdfgrid,[1]))
else:
cdfgrid = pdfgrid.cumsum()/pdfgrid.cumsum().max()
cdf_fn = interpolate(pts,cdfgrid,s=0)
def cdf(x):
x = np.atleast_1d(x)
y = np.atleast_1d(cdf_fn(x))
y[np.where(x < self.minval)] = 0
y[np.where(x > self.maxval)] = 1
return y
self.cdf = cdf
def power_spectrum_transfer_function(frequency,
t,
contrast,
fAMs,
kernel,
nperseg,
amp=1,
**cellparams):
"""
Calculate the transfer function for a given set of AM (amplitude modulation) frequencies and cell model
Parameters
----------
frequency: float
The stimulus sine frequency
t: 1-D array
The time aray
contrast: float
The AM strength (can be between 0 and inf)
fAMs: 1-D array
The array containing the AM frequencies
kernel: 1-D array
The kernel array for convolution
nperseg: float
The power spectrum nperseg variable
amp: float
The amplitude of the sinus wave, set to 1 by default.
*stimulusparams: list
List of stimulus parameters.
**cellparams: dictionary
Dictionary containing parameters of the cell model
Returns
-------
tfAMs: 1-D array
The array containing the transfer function values for the given array of fAMs.
"""
pfAMs = np.zeros(len(fAMs))
for idx, fAM in enumerate(fAMs):
stimulus = amp * np.sin(2 * np.pi * frequency * t) * (
1 + contrast * np.sin(2 * np.pi * fAM * t))
spiketimes = mod.simulate(stimulus, **cellparams)
f, p, __ = power_spectrum(stimulus, spiketimes, t, kernel, nperseg)
power_interpolator = interpolate(f, p)
pfAMs[idx] = power_interpolator(fAM)
tfAMs = np.sqrt(pfAMs) / contrast #transfer function value
return tfAMs
def load(self):
(magic,curve_count)=self.read(">hh")
for i in range(0, curve_count):
self.curves.append(self.loadcurve())
for c in self.curves:
x = [v[0] for v in c]
y = [v[1] for v in c]
if(len(x) > 2):
f = interpolate(x, y, kind='cubic')
sweep = xrange(0,256)
values = [int(round(v)) for v in f(xrange(0,256))]
self.precomputed.append(zip(sweep, values))
else:
# interpolate(x,y)
# but this is useless - why bother
# usually will just be a 0,0 - 255,255 line
self.precomputed.append([])
def __init__(self,pdf,cdf=None,name='',minval=-np.inf,maxval=np.inf,norm=None,
cdf_pts=500,keywords=None):
self.name = name
self.pdf = pdf
self.cdf = cdf
self.minval = minval
self.maxval = maxval
if keywords is None:
self.keywords = {}
else:
self.keywords = keywords
self.keywords['name'] = name
self.keywords['minval'] = minval
self.keywords['maxval'] = maxval
if norm is None:
self.norm = quad(self.pdf,minval,maxval,full_output=1)[0]
else:
self.norm = norm
if cdf is None and (minval == -np.inf or maxval == np.inf):
raise ValueError('must provide either explicit cdf function or explicit min/max values')
else: #tabulate & interpolate CDF.
pts = np.linspace(minval,maxval,cdf_pts)
pdfgrid = self(pts)
cdfgrid = pdfgrid.cumsum()/pdfgrid.cumsum().max()
cdf_fn = interpolate(pts,cdfgrid,s=0,k=1)
def cdf(x):
x = np.atleast_1d(x)
y = np.atleast_1d(cdf_fn(x))
y[np.where(x < self.minval)] = 0
y[np.where(x > self.maxval)] = 1
return y
self.cdf = cdf
#define minval_cdf, maxval_cdf
zero_mask = cdfgrid==0
one_mask = cdfgrid==1
if zero_mask.sum()>0:
self.minval_cdf = pts[zero_mask][-1] #last 0 value
if one_mask.sum()>0:
self.maxval_cdf = pts[one_mask][0] #first 1 value
def __init__(self,R_dist,Prot_dist,vsini_dist,nsamples=1e3,
vgrid=None,npts=100,vgrid_pts=1000,vsini_corrected=False,
veq_simple=False,
N_veq_samples=1e3,alpha=0.23,l0=20,sigl=20,
veq_bandwidth=0.1):
if type(R_dist) == type(''):
R_dist = dists.Distribution_FromH5(R_dist,'radius')
elif type(R_dist) in [type([]),type((1,))]:
if len(R_dist)==2:
R,dR = R_dist
R=float(R); dR=float(dR)
R_dist = dists.Gaussian_Distribution(R,dR,name='radius')
elif len(R_dist)==3:
R_dist = dists.fit_doublegauss(float(R_dist[0]),float(R_dist[1]),float(R_dist[2]),name='radius')
if type(Prot_dist) in [type([]),type((1,))]:
P,dP = Prot_dist
P=float(P); dP=float(dP)
Prot_dist = dists.Gaussian_Distribution(P,dP,name='Prot')
if type(vsini_dist) in [type([]),type((1,))]:
vsini,dvsini = vsini_dist
vsini=float(vsini); dvsini=float(dvsini)
if not vsini_corrected:
vsini = float(vsini)/(1 - (alpha/2))
vsini_dist = dists.Gaussian_Distribution(vsini,dvsini,name='vsini')
if vsini_dist.minval < 0:
vsini_dist.minval = 0
if veq_simple:
veq_dist = Veq_Distribution_Simple(R,dR,P,dP)
else:
veq_dist = Veq_Distribution(R_dist,Prot_dist,N=N_veq_samples,
alpha=alpha,l0=l0,sigl=sigl,
bandwidth=veq_bandwidth)
self.vsini_dist = vsini_dist
self.veq_dist = veq_dist
cs,Ls = cosi_posterior(vsini_dist, veq_dist, vgrid=vgrid,
npts=npts, vgrid_pts=vgrid_pts)
self.samples = sample_posterior(cs,Ls,nsamples=nsamples)
pdf = interpolate(cs,Ls,s=0)
dists.Distribution.__init__(self,pdf,name='cos(I)',
minval=0,maxval=1)
def Equation_Of_State_NS(P):
POW = 3
z_i = np.zeros(9 * POW)
for i in np.arange(POW):
for j in np.arange(9):
z_i[i * 9 + j] = (j + 1) * pow(10., i - 3)
z = np.insert(z_i, 0, 0)
N = 1 #*mn[SYS]*c[SYS]**2/(np.pi**2*ln[SYS]**3)
P_NS = N / 8 * ((2 * z**3 / 3 - z) * np.sqrt(1 + z * z) + np.arcsinh(z))
E_NS = N / 8 * ((2 * z**3 + z) * np.sqrt(1 + z * z) - np.arcsinh(z))
f = interpolate(P_NS, E_NS)
return f(P)
def __init__(self, rs, dmags, band, mag=None, name=None):
# if band=='K' or band=="K'":
# band = 'Ks'
rs = np.atleast_1d(rs)
dmags = np.atleast_1d(dmags)
self.rs = rs
self.dmags = dmags
self.band = band
self.mag = mag
self.contrastfn = interpolate(rs, dmags, s=0)
self.rmax = rs.max()
self.rmin = rs.min()
if name is None:
self.name = "%s band" % self.band
else:
self.name = name
def __init__(self,rs,dmags,band,mag=None,name=None):
#if band=='K' or band=="K'":
# band = 'Ks'
rs = np.atleast_1d(rs)
dmags = np.atleast_1d(dmags)
self.rs = rs
self.dmags = dmags
self.band = band
self.mag = mag
self.contrastfn = interpolate(rs,dmags,s=0)
self.rmax = rs.max()
self.rmin = rs.min()
if name is None:
self.name = '%s band' % self.band
else:
self.name = name
def __init__(self,vs,dmags,band='g'):
self.vs = vs
self.dmags = dmags
self.band = band
if np.size(vs) > 1:
self.contrastfn = interpolate(vs,dmags,s=0)
self.vmax = vs.max()
self.vmin = vs.min()
else: #simple case; one v, one dmag
def cfn(v):
v = np.atleast_1d(abs(v))
dmags = np.zeros(v.shape)
dmags[v>=self.vs] = self.dmags
dmags[v<self.vs] = 0
return dmags
self.contrastfn = cfn
self.vmax = self.vs
self.vmin = self.vs
def __init__(self, rs, dmags, band, mag=None, name=None):
"""band is self-explanatory; 'mag' is mag of the primary in 'band' """
#if band=='K' or band=="K'":
# band = 'Ks'
rs = np.atleast_1d(rs)
dmags = np.atleast_1d(dmags)
self.rs = rs
self.dmags = dmags
self.band = band
self.mag = mag
self.contrastfn = interpolate(rs, dmags, s=0)
self.rmax = rs.max()
self.rmin = rs.min()
if name is None:
self.name = '%s band' % self.band
else:
self.name = name
def interpolate_diff_model(self,model_int=None):
if model_int is None:
model_timeseries = self.normalized_roi0_intensity
else:
model_timeseries = model_int
interpolated_function = interpolate(self.cut_model_time,model_timeseries[self.cut_model_idx])
interpolated_model = interpolated_function(self.cut_exp_time)
interpolated_model = np.reshape(interpolated_model,np.shape(self.cut_exp_roi0))
residuals = np.subtract(interpolated_model,self.cut_exp_roi0)
if model_int is None:
self.interpolated_model = np.copy(interpolated_model)
self.residuals = np.copy(residuals)
else:
return interpolated_model,residuals
def rectify_basis(wave, spectra, wlow=0, whigh=np.inf,
exclude=[], outwave=None, filters=None, **extras):
"""Mask a spectral basis using lists of include and exclude ranges
"""
if filters is not None:
flist = observate.load_filters(filters)
sed = observate.getSED(wave, spectra, filterlist=flist)
return np.array([f.wave_effective for f in flist]), 10**(-0.4 * sed)
if outwave is not None:
onedinterp = interpolate(wave, spectra, axis=-1)
spectra = onedinterp(outwave)
wave = outwave
g = (wave >= wlow) & (wave <= whigh)
for (lo, hi) in exclude:
g = g & ((wave < lo) | (wave > hi))
return wave[g], spectra[:, g]
def __init__(self,
k,
p,
Qfile=None,
Rfile=None,
npool=4,
extrapker=True,
saveqfile=None):
self.kp = k
self.p = p
self.ipk = interpolate(k, p)
self.ilpk = self.loginterp(k, p)
self.renorm = numpy.sqrt(numpy.pi / 2.)
self.tpi2 = 2 * numpy.pi**2.
self.kint = numpy.logspace(-5, 6, 1e4)
self.npool = npool
self.extrapker = extrapker #If the kernels should be extrapolated. True recommended
if Qfile is None:
self.kq, self.Q1, self.Q2, self.Q3, self.Q5, self.Q8, self.Qs2 = self.calc_Q(
)
else:
print("Reading in Qs from" + Qfile)
self.kq, self.Q1, self.Q2, self.Q3, self.Q5, self.Q8, self.Qs2 = numpy.loadtxt(
Qfile)
self.ilQ1 = self.loginterp(self.kq, self.Q1, rp=-5)
self.ilQ2 = self.loginterp(self.kq, self.Q2, rp=-5)
self.ilQ3 = self.loginterp(self.kq, self.Q3, rp=-5)
self.ilQ5 = self.loginterp(self.kq, self.Q5, rp=-5)
self.ilQ8 = self.loginterp(self.kq, self.Q8, rp=-5)
self.ilQs2 = self.loginterp(self.kq, self.Qs2, rp=-5)
if Rfile is None:
self.kr, self.R1, self.R2 = self.calc_R()
else:
print("Reading in Rs from" + Rfile)
self.kr, self.R1, self.R2 = numpy.loadtxt(Rfile)
self.ilR1 = self.loginterp(self.kr, self.R1)
self.ilR2 = self.loginterp(self.kr, self.R2)
if saveqfile is not None:
self.save_qfunc(saveqfile)
def setup(self):
'''
Create X_L, Y_L, xi_L, U1_L \& 0lag sigma.
'''
self.xi0lag = self.xi0lin0()
self.qv, xi0v = self.xi0lin()
xi2v = self.xi2lin()[1]
self.corlin = self.corr()[1]
self.Ulin = self.u10lin()[1]
#
self.Xlin = 2 / 3. * (self.xi0lag - xi0v - xi2v)
ylinv = 2 * xi2v
#Since we divide by ylin, check for zeros
mask = (ylinv == 0)
ylinv[mask] = interpolate(self.qv[~mask], ylinv[~mask])(self.qv[mask])
self.Ylin = ylinv
self.XYlin = (self.Xlin + self.Ylin)
self.sigma = self.XYlin[-1]
self.yq = (1 * self.Ylin / self.qv)
def symmetrize_dihedral(angles, energies, regions):
sym_profile = np.array([])
energy_sum = np.inf
angles_deg = np.degrees(angles)
spacing = get_periodic_angle(abs(angles_deg[1] - angles_deg[0]))
for region in regions:
select = get_periodic_range(angles_deg, region['start'],
region['end'], spacing)
ang_reg = angles_deg[select]
energy_reg = energies[select]
ang_continious = np.copy(ang_reg)
ang_continious[ang_reg < region['start'] - spacing] += 360
ip_funct = interpolate(ang_continious,
energy_reg,
fill_value="extrapolate",
kind=2)
ip_angle = np.arange(
region['start'],
make_contin(region['start'], region['end']) + 1)
ip_energy = ip_funct(ip_angle)
if ip_energy.sum() < energy_sum:
energy_sum = ip_energy.sum()
if not region['direct']:
lowest = ip_energy[::-1]
else:
lowest = ip_energy
for region in regions:
if region['direct']:
current = lowest
else:
current = lowest[::-1]
sym_profile = np.concatenate((sym_profile, current[:-1]))
sym_angle = np.radians(
np.arange(regions[0]['start'],
make_contin(regions[0]['start'], regions[-1]['end'])))
sym_profile -= sym_profile.min()
return sym_angle, sym_profile
def _eval_Dplus(self):
"""return un-normalized D(a)
...evaluated only once because lazy"""
M = self.M
L = self.L
H0 = self.H0
logamin = -20.
Np = 1000
logx = numpy.linspace(logamin, 0, Np)
x = numpy.exp(logx)
def kernel(loga):
a = numpy.exp(loga)
return (a * self.Ea(a=a))**-3 * a # da = a * d loga
y = self.Ea(a=x) * numpy.array([
romberg(kernel, logx.min(), loga, vec_func=True) for loga in logx
])
return interpolate(x, y)
def _Dgrow(z, M, L = None, H0 = 100):
"""return D(a)/D(1.)"""
a = 1/(1+z)
if L is None:
L = 1-M
logamin = -20.
Np = 1000
logx = numpy.linspace(logamin, 0, Np)
x = numpy.exp(logx)
Ea = lambda a: (a ** -1.5 * (M + (1 - M - L) * a + L * a ** 3) ** 0.5)
def kernel(loga):
a = numpy.exp(loga)
return (a * Ea(a = a)) ** -3 * a # da = a * d loga
y = Ea(a = x) * numpy.array([ romberg(kernel, logx.min(), loga, vec_func=True) for loga in logx])
Da = interpolate(x, y)
return Da(a)/Da(1.)
def __init__(self, vs, dmags, band="g"):
self.vs = vs
self.dmags = dmags
self.band = band
if np.size(vs) > 1:
self.contrastfn = interpolate(vs, dmags, s=0)
self.vmax = vs.max()
self.vmin = vs.min()
else: # simple case; one v, one dmag
def cfn(v):
v = np.atleast_1d(abs(v))
dmags = np.zeros(v.shape)
dmags[v >= self.vs] = self.dmags
dmags[v < self.vs] = 0
return dmags
self.contrastfn = cfn
self.vmax = self.vs
self.vmin = self.vs
def _plot(self, ax=None):
if ax is None:
ax = plt.gca()
# Consider order of plotted graphs to increase z-order appropriately
# This ensure that each graph neatly overlays over the last and is not
# stacked in the same z-layer.
for i, (x, y, color, fmt, fill, alpha) in enumerate(self._graphs):
if fmt == 'interpolate':
x_new = np.linspace(min(x), max(x), RESOLUTION)
x, y = x_new, interpolate(x, y)(x_new)
# Fill under x, y values with the same color as the plot. Otherwise
# plot just the line.
if fill is True:
ax.fill_between(x, [0] * len(x),
y,
interpolate=True,
lw=None,
edgecolor=None,
facecolor=color,
antialiased=True,
alpha=alpha,
zorder=2.7 + i)
else:
ax.plot(x, y, color=color, alpha=alpha, zorder=2.7 + i)
if max(ax.get_ylim()) > 999:
ax = ticklabels_to_thousands_sep(ax, 'y')
# If this is proportional data then convert y-axis to percents.
if self.is_proportional is True:
ax = ticklabels_to_percent(ax, 'y')
for k, spine in ax.spines.items():
spine.set_zorder(2.7 + i + 1)
ax.yaxis.grid(True, color='0.8', ls='-', zorder=0)
ax.set_ylim(0, ax.get_ylim()[1])
return ax
def createicdf(pdf=None, mv=None, mfv=None, Mthresh=10**10.5, M0=1e13):
'''For the galaxies, based on the functions from Reddick et.al above
Create a cdf for a halo mass and then sample from ssampleicdf
- pdf (f) should be with the differential of log10(M)
'''
Nint = 500 #No.of points to interpolate
if pdf is None:
if mfv is None:
print('need pdf or the values to interpolate over')
return None
else:
imf = interpolate(mv, mfv, k=5)
else:
imf = pdf
ilmf = lambda x: imf(10**(x))
lmm = np.linspace(np.log10(M0), np.log10(Mthresh), Nint)
#Calculate the other mass-limit M2 of the catalog by integrating mf and comparing total number of halos
nbin = abs(
np.array(
[romberg(ilmf, lmm[i], lmm[i + 1]) for i in range(lmm.size - 1)]))
ncum = np.cumsum(nbin)
ncum /= ncum.max()
lmm = 0.5 * (lmm[:-1] + lmm[1:])
if (ncum == 0).sum() > 0:
zeros = np.where(ncum == 0)[0]
ncum = ncum[zeros[-1]:]
lmm = lmm[zeros[-1]:]
if (ncum == 1).sum() > 0:
ones = np.where(ncum == 1)[0]
ncum = ncum[:ones[0] + 1]
lmm = lmm[:ones[0] + 1]
#try: icdf = interpolate(ncum, lmm)
try:
icdf = interp1d(ncum, lmm)
except Exception as e:
print(e)
print(ncum, lmm)
return icdf
def setup(self):
'''
Create X_L, Y_L, xi_L, U1_L \& 0lag sigma.
'''
self.xi0lag = self.xi0lin0()
self.qv, xi0v = self.xi0lin()
xi2v = self.xi2lin(
tilt=-0.5)[1] # this tilt gives better low q behavior
self.corlin = self.corr()[1]
self.Ulin = self.u10lin()[1]
#
self.Xlin = 2 / 3. * (self.xi0lag - xi0v - xi2v)
ylinv = 2 * xi2v
#Since we divide by ylin, check for zeros
mask = (ylinv == 0)
ylinv[mask] = interpolate(self.qv[~mask], ylinv[~mask])(self.qv[mask])
self.Ylin = ylinv
self.XYlin = (self.Xlin + self.Ylin)
self.sigma = self.XYlin[-1]
self.yq = (1 * self.Ylin / self.qv)
# calculate shear terms
xi0lin = self.xi0lin(k_power=2, tilt=1.5)[1]
xi2lin = self.xi2lin(k_power=2, tilt=0.5)[1]
xi4lin = self.xi4lin(k_power=2, tilt=0.5)[1]
xi1lin = self.xi1lin(k_power=1, tilt=0.5)[1]
xi3lin = self.xi3lin(k_power=1, tilt=0.5)[1]
J2 = 2. * xi1lin / 15 - 0.2 * xi3lin
J3 = -0.2 * xi1lin - 0.2 * xi3lin
J4 = xi3lin
self.zeta = 2 * (4 * xi0lin**2 / 45. + 8 * xi2lin**2 / 63. +
8 * xi4lin**2 / 35)
self.chi = 4 * xi2lin**2 / 3.
self.V = 4 * J2 * xi2lin
self.Xs2 = 4 * J3**2
self.Ys2 = 6 * J2**2 + 8 * J2 * J3 + 4 * J2 * J4 + 4 * J3**2 + 8 * J3 * J4 + 2 * J4**2
def hmp(self, rbins, rhocritperh):
"""Generating halo mass profiles of each halo
Parameters
----------
rbins : array of float
Radius bin edges
rhocritperh : float
Critical density
"""
self.profiles = []
self.r = rbins
for i, halo in enumerate(self.halos):
_write('\rGenerating halo mass profile [%d out of %d]',
(i + 1, len(self.halos)))
sorted_distances = _sorteddistances(halo, self.particles)
self.profiles.append(_densitycalc(
sorted_distances, rbins, self.pmass, rhocritperh))
_write('[done]\n')
# Stacking profiles
self.rho_rhocrit = []
for i in range(len(self.r)):
self.rho_rhocrit.append(
sum([d[i] for d in self.profiles]) / len(self.profiles))
# Finding r200
reduced_profile = [r - 200.0 for r in self.rho_rhocrit]
profile_func = interpolate(self.r, reduced_profile)
r200 = profile_func.roots()[0]
self.rr200 = [r / r200 for r in self.r]
def hmp(self, rbins, rhocritperh):
"""Generating halo mass profiles of each halo
Parameters
----------
rbins : array of float
Radius bin edges
rhocritperh : float
Critical density
"""
self.profiles = []
self.r = rbins
for i, halo in enumerate(self.halos):
_write('\rGenerating halo mass profile [%d out of %d]',
(i + 1, len(self.halos)))
sorted_distances = _sorteddistances(halo, self.particles)
self.profiles.append(
_densitycalc(sorted_distances, rbins, self.pmass, rhocritperh))
_write('[done]\n')
# Stacking profiles
self.rho_rhocrit = []
for i in range(len(self.r)):
self.rho_rhocrit.append(
sum([d[i] for d in self.profiles]) / len(self.profiles))
# Finding r200
reduced_profile = [r - 200.0 for r in self.rho_rhocrit]
profile_func = interpolate(self.r, reduced_profile)
r200 = profile_func.roots()[0]
self.rr200 = [r / r200 for r in self.r]
def stellar_relation():
x1 = 10**15 * 1.6
x2 = 10**12 * 4
y1 = x1 * 1.5 * 10**-3
y2 = x2 * 3.2 * 10**-2
line1, dummy = cf(line, numpy.array([log10(x1), log10(x2)]),
numpy.array([log10(y1), log10(y2)]))
y1 = x1 * 3.5 * 10**-4
y2 = x2 * 2.2 * 10**-2
line2, dummy = cf(line, numpy.array([log10(x1), log10(x2)]),
numpy.array([log10(y1), log10(y2)]))
#mean line
m = (line1[0] + line2[0]) * 0.5
c = (line1[1] + line2[1]) * 0.5
xval = numpy.linspace(log10(x2), log10(x1))
xline = line(xval, m, c)
stellar_sigma = interpolate(
xline, 0.01 + (line(xval, line1[0], line1[1]) - xline))
return stellar_sigma, m, c
def setup_dm(self):
qf = self.qf
#Linear
self.xi00lin = qf.xi0lin0()
self.qv, xi0lin = qf.xi0lin() #qv determined here
xi2lin = qf.xi2lin()[1]
self.Xlin = 2/3.*(self.xi00lin - xi0lin - xi2lin)
ylinv = 2*xi2lin
#Since we divide by ylin, check for zeros
mask = (ylinv == 0)
ylinv[mask] = interpolate(self.qv[~mask], ylinv[~mask])(self.qv[mask])
self.Ylin = ylinv
#Useful variables here
self.XYlin = (self.Xlin + self.Ylin)
self.sigma = self.XYlin[-1]
self.yq = (1*self.Ylin/self.qv)
#Loop
if self.order == 2:
self.xi00loop = qf.xi0loop0()
xi0loop = qf.xi0loop()[1]
xi2loop = qf.xi2loop()[1]
self.Xloop = 2/3.*(self.xi00loop - xi0loop - xi2loop)
self.Yloop = 2*xi2loop
self.XYloop = (self.Xloop + self.Yloop)
self.sigmaloop = self.XYloop[-1]
#Loop2
self.xi1loop = qf.xi1loop(tilt = 0.5)[1]
self.xi3loop = qf.xi3loop(tilt = 0.5)[1]
else:
self.Xloop, self.Yloop, self.XYloop, self.xi1loop, self.xi3loop = [np.zeros_like(self.qv) for i in range(5)]
self.sigmaloop = 0
def Halos(bs, nc, seed, nstep, seed_hod, Omega_m, p_alpha, p_logMin, p_logM1, p_logM0, p_sigma_logM):
'''
'''
# setup initial conditions
Omegacdm = Omega_m-0.049,
cosmo = NBlab.cosmology.Planck15.clone(Omega_cdm=Omegacdm,
h = 0.6711, Omega_b = 0.049)
power = NBlab.cosmology.LinearPower(cosmo, 0)
klin = np.logspace(-4,2,1000)
plin = power(klin)
pkfunc = interpolate(klin, plin)
# run the simulation
pm = ParticleMesh(BoxSize=bs, Nmesh=[nc, nc, nc])
Q = pm.generate_uniform_particle_grid()
stages = numpy.linspace(0.1, 1.0, nstep, endpoint=True)
solver = Solver(pm, cosmo, B=2)
wn = solver.whitenoise(seed)
dlin = solver.linear(wn, pkfunc)
state = solver.lpt(dlin, Q, stages[0])
state = solver.nbody(state, leapfrog(stages))
# create the catalogue
cat = ArrayCatalog({'Position' : state.X,
'Velocity' : state.V,
'Displacement' : state.S,
'Density' : state.RHO},
BoxSize=pm.BoxSize,
Nmesh=pm.Nmesh,
M0 = Omega_m * 27.75e10 * bs**3 / (nc/2.0)**3)
cat['KDDensity'] = KDDensity(cat).density
# run FOF to construct Halo catalog
fof = FOF(cat, linking_length=0.2, nmin=12)
fofcat = fof.to_halos(particle_mass=cat.attrs['M0'], cosmo = cosmo, redshift = 0.0)
return fofcat
def setup(self):
'''
Create X_L, Y_L, xi_L, U1_L \& 0lag sigma.
These will all be dictionaries labelled by 'species', except for the X, Y terms,
which we'll have to deal with separately...
'''
self.qv, xi0v = self.xi0lin()
pairs = ['mm', 'dm', 'sm', 'dd', 'ds', 'ss']
self.corlins = {}
self.Ulins = {}
self.Xlins = {}
self.Ylins = {}
self.XYlins = {}
self.sigmas = {}
self.yqs = {}
for pair in pairs:
# the sign of the spectra of the shift field are hereby fixed....
if pair == 'sm' or pair == 'ds':
s = -1
else:
s = +1
q_p = -0.5
print('Calculating 2-pt functions for species pair ' + pair,
'tilt = ' + str(q_p))
xi0lag = self.xi0lin0(species=pair)
xi0v = s * self.xi0lin(
species=pair, tilt=-q_p)[1] # used to be 1 + q_p which was bad
xi2v = s * self.xi2lin(species=pair, tilt=-q_p)[1]
self.Xlins[pair] = 2 / 3. * (xi0lag - xi0v - xi2v)
# Check Ylin for zeros
ylinv = 2 * xi2v
mask = (ylinv == 0)
ylinv[mask] = interpolate(self.qv[~mask],
ylinv[~mask])(self.qv[mask])
self.Ylins[pair] = ylinv
self.yqs[pair] = (1 * self.Ylins[pair] / self.qv)
self.XYlins[pair] = self.Xlins[pair] + self.Ylins[pair]
self.sigmas[pair] = self.XYlins[pair][-1]
self.corlins[pair] = s * self.corr(
species=pair, tilt=1.5)[1] # used to be 3 + q_p
self.Ulins[pair] = s * self.u10lin(
species=pair, tilt=1.5)[1] # used to be 2 + qp
self.XYlin_mm = self.Xlins['mm'] + self.Ylins['mm']
self.sigma_mm = self.XYlin_mm[-1]
self.XYlin_dd = self.Xlins['dd'] + self.Ylins['dd']
self.sigma_dd = self.XYlin_dd[-1]
self.XYlin_ds = self.Xlins['ds'] + self.Ylins['ds']
self.sigma_ds = self.XYlin_ds[-1]
self.XYlin_ss = self.Xlins['ss'] + self.Ylins['ss']
self.sigma_ss = self.XYlin_ss[-1]
# calculate shear correlators
self.zetas = {}
self.chis = {}
self.Xs2s = {}
self.Ys2s = {}
self.Vs = {}
xi2lin_mm = self.xi2lin(species='mm', k_power=2)[1]
for pair in ['mm', 'dm', 'sm']:
if pair != 'mm':
tilt = 0
else:
tilt = 1.5
if pair == 'sm' or pair == 'ds':
s = -1
else:
s = +1
xi0lin = s * self.xi0lin(species=pair, k_power=2, tilt=1.5)[1]
xi2lin = s * self.xi2lin(species=pair, k_power=2, tilt=0.5)[1]
xi4lin = s * self.xi4lin(species=pair, k_power=2, tilt=0.5)[1]
xi1lin = s * self.xi1lin(species=pair, k_power=1, tilt=0.5)[1]
xi3lin = s * self.xi3lin(species=pair, k_power=1, tilt=0.5)[1]
J2 = 2. * xi1lin / 15 - 0.2 * xi3lin
J3 = -0.2 * xi1lin - 0.2 * xi3lin
J4 = xi3lin
self.zetas[pair] = 2 * (4 * xi0lin**2 / 45. + 8 * xi2lin**2 / 63. +
8 * xi4lin**2 / 35)
self.chis[pair] = 4 * xi2lin**2 / 3.
self.Vs[pair] = 4 * J2 * xi2lin_mm
self.Xs2s[pair] = 4 * J3**2
self.Ys2s[
pair] = 6 * J2**2 + 8 * J2 * J3 + 4 * J2 * J4 + 4 * J3**2 + 8 * J3 * J4 + 2 * J4**2
'resolution': t_delta
} #kernel is muhc shorter for power spectrum
#create kernel
kernel, kerneltime = helpers.spike_gauss_kernel(**kernelparams)
#power spectrum parameters:
nperseg = 2**15
spiketimes = mod.simulate(stimulus, **cellparams)
fexample, pexample, meanspkfr = helpers.power_spectrum(
stimulus, spiketimes, t, kernel, nperseg)
pdB = helpers.decibel_transformer(pexample)
power_interpolator_decibel = interpolate(fexample, pdB)
#stimulus power spectrum
fexamplestim, pexamplestim = welch(
np.abs(stimulus - np.mean(stimulus)), nperseg=nperseg,
fs=1 / t_delta) #zero peak of power spectrum is part of the stimulus,
#which stays even when stimulus mean is substracted.
#take absolute value to get the envelope
pdBstim = helpers.decibel_transformer(pexamplestim)
#cell f-I curve
dataframe = pd.read_csv(savepath + '\\' + datafiles[cell_idx])
vals = dataframe.to_numpy()
baselinefs = vals[:, 0][~np.isnan(vals[:, 0])]
initialfs = vals[:, 1][~np.isnan(vals[:, 1])]
steadyfs = vals[:, 2][~np.isnan(vals[:, 2])]
import numpy as np
from scipy.interpolate import UnivariateSpline as interpolate
import cosmo_functions as cf
#import pmfs_fisher as pf
reload(cf)
from constants import *
from globals import *
#set up kappas:
KAPPA = np.loadtxt(INPUTS_PATH + 'Kcoeffexpanded.txt')
TKAPPA = KAPPA[:, 0]
KAPPAP = KAPPA[:, 1]
KAPPAM = KAPPA[:, 2]
val_kappam = interpolate(TKAPPA, KAPPAM, s=0)
val_kappap = interpolate(TKAPPA, KAPPAP, s=0)
#from Allison & Delgarno 1969:
kappa10_array = np.array([
2.2e-14, 4.2e-14, 1.8e-13, 5.1e-13, 1.2e-12, 2.3e-12, 7.4e-12, 1.5e-11,
2.3e-11, 3.0e-11, 4.4e-11, 5.6e-11, 6.6e-11, 7.4e-11, 8.2e-11, 8.9e-11,
9.5e-11, 1.4e-10, 1.6e-10, 1.8e-10, 2.0e-10, 2.1e-10, 2.2e-10, 2.3e-10,
2.4e-10, 2.5e-10
])
T_kappa10_array = np.array([
1, 2, 4, 6, 8, 10, 15, 20, 25, 30, 40, 50, 60, 70, 80, 90, 100, 200, 300,
400, 500, 600, 700, 800, 900, 1000
])
val_kappa10 = interpolate(T_kappa10_array, kappa10_array, s=0)
def _interpolate(self, x, z, **kwds):
from scipy.interpolate import CloughTocher2DInterpolator as interpolate
return interpolate(x, z, **kwds)
def _traceback_warp(self):
# setup initial position & warp parameter values for each region
X0, Y0 = self.regions_X0, self.regions_Y0
shape = self.regions_X0.shape
P0, P1, P2, P3, P4, P5 = [
np.array([a.p[b] for a in self.frame[0].region]).reshape(shape)
for b in xrange(6)]
# setup parameters for smoothing before back-interpolating)
if self.smoothtraceback:
sgargs = {'window_length':11, 'polyorder': 3, 'mode':'interp'}
if sgargs['window_length'] > np.min(X0.shape):
warnings.warn('Too few regions to smooth data during traceback. Skipping.')
self.smoothtraceback = False
# for each time point
for tt in xrange(1, self.num_frames):
# data for each warp parameter at each region in current frame
# warp is from previous to current frame
d0, d1, d2, d3, d4, d5 = [
np.array([a.p[b] for a in self.frame[tt].region]).reshape(shape)
for b in range(6)]
# smooth this data before creating interpolant
if self.smoothtraceback:
d0, d1, d2, d3, d4, d5 = [
sgfilt(sgfilt(a, axis=0, **sgargs), axis=1, **sgargs)
for a in (d0, d1, d2, d3, d4, d5)]
# gargs = {'sigma': 1., 'mode':'reflect'}
# d0, d1, d2, d3, d4, d5 = [
# sp.ndimage.filters.gaussian_filter(a, **gargs)
# for a in (d0, d1, d2, d3, d4, d5)]
# scalar field interpolants for each parameter
verts = (self.regions_Yv, self.regions_Xv)
iargs = {'bounds_error':False, 'fill_value':None}
i0, i1, i2, i3, i4, i5 = [interpolate(verts, a, **iargs)
for a in (d0, d1, d2, d3, d4, d5)]
for rr in xrange(self.num_regions):
# previous region center
pt = np.vstack((Y0.flat[rr], X0.flat[rr])).T
# previous parameters
P = [a.flat[rr] for a in (P0, P1, P2, P3, P4, P5)]
# previous F
F = getF(P)
# in-between parameters
ptmp = [a(pt)[0] for a in (i0, i1, i2, i3, i4, i5)]
# in-between F
ftmp = getF(ptmp)
# new F
f = np.dot(ftmp, F)
# new parameters
p = np.array((f[0,0]-1, f[1,0], f[0,1],
f[1,1]-1, ptmp[4]+P4.flat[rr],
ptmp[5]+P5.flat[rr]), dtype=float)
# new region center
x0, y0 = X0.flat[rr] + p[4], Y0.flat[rr] + p[5]
# overwrite current values as initial values for next time pt
X0.flat[rr], Y0.flat[rr] = x0, y0
P0.flat[rr], P1.flat[rr], P2.flat[rr], P3.flat[rr], \
P4.flat[rr], P5.flat[rr] = p
# store warp parameters for current region in current frame
self.frame[tt].region[rr].set_warped_coordinates(p)
def __init__(self,xs,pdf,smooth=0,**kwargs):
pdf /= np.trapz(pdf,xs)
fn = interpolate(xs,pdf,s=smooth)
keywords = {'smooth':smooth}
Distribution.__init__(self,fn,minval=xs.min(),maxval=xs.max(),
keywords=keywords,**kwargs)
def _interpolate(self, x, z, **kwds):
from scipy.interpolate import CloughTocher2DInterpolator as interpolate
return interpolate(x, z, **kwds)
def get_interpolation(self, parameter_name_x, parameter_name_y, **kwargs):
return interpolate(self.get_value_list(parameter_name_x),
self.get_value_list(parameter_name_y),
**kwargs)
def sigmaf(self, aa=1.):
""" returns interpolating function for sigma. syntax to use - sigmaf(a)(M)"""
d = self.cosmo.Dgrow(a=aa)
return interpolate(self.masses, d * self.sigma)
def icdf_sampling(bs,
mf=None,
mv=None,
mfv=None,
match_high=True,
hmass=None,
M0=None,
N0=None,
seed=100):
'''
Given samples from analytic mass function (dN/dln(M)), find halo masss by matching abundance via
inverse cdf sampling.
bs : boxsize
mv, mfv : (Semi-optional) analytic hmf sampled at masses 'mv'
mf : (Semi-optional) Analytic hmf, if mv and mfv are not given
match_high : if True, Match the highest mass of the catalog to analytic mass.
if False, match the lowest mass
hmass : (Semi-Optional) Halo mass catalog, used to calculate highest/lowest mass
and number of halos
M0, N0 : (Semi-optional) If mass catalog not given, M0 and N0 are required to
correspond to highest/lowest mass and number if halos
Returns: Abundance matched halo mass catalog
'''
Nint = 500 #No.of points to interpolate
#Create interpolating function for mass_func
if mf is not None:
mv = np.logspace(10, 17, Nint)
mfv = mf(mv)
elif mv is None:
print(
"Need either a function or values sampled from the analytic mass function to match against"
)
return None
#Interpolate
imf = interpolate(mv, mfv, k=5)
ilmf = lambda x: imf(np.exp(x))
#Create array to integrate high or low from the matched mass based on match_high
if N0 is None:
N0 = hmass.size
if match_high:
if M0 is None:
if hmass is None:
print(
"Need either a halo mass catalog or a mass to be matched at"
)
return 0
else:
M0 = hmass.max()
lmm = np.linspace(np.log(M0), np.log(mv.min()), Nint)
else:
if M0 is None:
M0 = hmass.min()
lmm = np.linspace(np.log(M0), np.log(mv.max()), Nint)
#Calculate the other mass-limit M2 of the catalog by integrating mf and comparing total number of halos
ncum = abs(
np.array([romberg(ilmf, lmm[0], lmm[i])
for i in range(lmm.size)])) * bs**3
M2 = np.exp(np.interp(N0, ncum, lmm))
#Create pdf and cdf for N(M) from mf between M0 and M2
lmm2 = np.linspace(np.log(M0), np.log(M2), Nint)
nbin = abs(
np.array([
romberg(ilmf, lmm2[i], lmm2[i + 1]) for i in range(lmm2.size - 1)
])) * bs**3
nprob = nbin / nbin.sum()
cdf = np.array([nprob[:i + 1].sum() for i in range(nprob.size)])
icdf = interpolate(cdf[:], 0.5 * (lmm2[:-1] + lmm2[1:]))
#Sample random points from uniform distribution and find corresponding mass
np.random.seed(seed)
ran = np.random.uniform(0, 1, N0)
hmatch = np.exp(icdf(ran))
hmatch.sort()
return hmatch[::-1]
import numpy as np
from scipy.interpolate import UnivariateSpline as interpolate
import cosmo_functions as cf
#import pmfs_fisher as pf
reload(cf)
from constants import *
from globals import *
#set up kappas:
KAPPA = np.loadtxt(INPUTS_PATH + 'Kcoeffexpanded.txt')
TKAPPA = KAPPA[:,0]
KAPPAP = KAPPA[:,1]
KAPPAM = KAPPA[:,2]
val_kappam = interpolate(TKAPPA, KAPPAM, s=0)
val_kappap = interpolate(TKAPPA, KAPPAP, s=0)
#from Allison & Delgarno 1969:
kappa10_array = np.array([2.2e-14,4.2e-14,1.8e-13,5.1e-13,1.2e-12,2.3e-12,7.4e-12,1.5e-11,2.3e-11,3.0e-11,4.4e-11,5.6e-11,6.6e-11,7.4e-11,8.2e-11,8.9e-11,9.5e-11,1.4e-10,1.6e-10,1.8e-10,2.0e-10,2.1e-10,2.2e-10,2.3e-10,2.4e-10,2.5e-10])
T_kappa10_array = np.array([1,2,4,6,8,10,15,20,25,30,40,50,60,70,80,90,100,200,300,400,500,600,700,800,900,1000])
val_kappa10 = interpolate(T_kappa10_array, kappa10_array, s=0)
Pnp = np.array([1, 0, 0.2609, 0.3078, 0.3259, 0.3353, 0.3410, 0.3448, 0.3476, 0.3496,
0.3512, 0.3524, 0.3535, 0.3543, 0.3550, 0.3556, 0.3561, 0.3565, 0.3569,
0.3572, 0.3575, 0.3578, 0.3580, 0.3582, 0.3584, 0.3586, 0.3587, 0.3589, 0.3590])
Pnp_ns = np.array([2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30])
Pnp_tuple = ((2,1.), (3,0), (4,0.2609), (5,0.3078), (6,0.3259), (7,0.3353), (8,0.3410), (9,0.3448),
(10,0.3476), (11,0.3496), (12,0.3512), (13,0.3524), (14,0.3535), (15,0.3543), (16,0.3550),
(17,0.3556), (18,0.3561), (19,0.3565), (20,0.3569), (21,0.3572), (22,0.3575), (23,0.3578),
legends=plot_data["Rmaxfactor"])
# Compute statistics for cover page
reporting = 8
# Efolds
efolds = []
for avals in plot_data["lna"]:
efolds.append(avals[-1])
# Two point phi
twoptphis = []
for i in range(len(plot_data["lna"])):
x = plot_data["lna"][i]
y = plot_data["phi2pt"][i]
interp = interpolate(x, y)
twoptphis.append(float(interp(reporting)))
# Two point phidot
twoptphidots = []
for i in range(len(plot_data["lna"])):
x = plot_data["lna"][i]
y = plot_data["phi2ptdt"][i]
interp = interpolate(x, y)
twoptphidots.append(float(interp(reporting)))
# Two point phigrad
twoptphigrads = []
for i in range(len(plot_data["lna"])):
x = plot_data["lna"][i]
y = plot_data["phi2ptgrad"][i]
def _interpolate(self, x, z, **kwds):
import numpy as np
from scipy.interpolate import Rbf as interpolate
return interpolate(*np.vstack((x.T, z)), **kwds)
def render_segment(self, seg, key):
print(" * Processing vector %d:" % (key + 1))
# get vector parameters from the GUI
harm_mode = self.gui.harm_mode_var[key].get()
harm_count = self.gui.harm_count_val[key]
midi_note_number = int(self.gui.baseline_freq[key].get())
read_time = int(self.gui.read_speed[key].get())
delay_time = int(self.gui.delay_time[key].get())
base_freq = self.midi_notes[midi_note_number]
# a list of frequencies for all harmonics in the vector
harmonic_freqs = []
harmonic_freqs.append(base_freq)
# create lists with random harmonics and frequencies in Hz
rnd_list = random.sample(range(2,256),128)
rnd_list_hz = random.sample(range(int(base_freq) + 10,SAMPLE_RATE // (ANTIALIASING + 1)),128)
# calculate frequencies of harmonics according to the selected formula ("harmonics mode" parameter)
for h in range(1,harm_count):
if harm_mode == 'All':
freq = base_freq * (h + 1)
harmonic_freqs.append(freq)
elif harm_mode == 'Even':
freq = base_freq * (h * 2)
harmonic_freqs.append(freq)
elif harm_mode == 'Odd':
freq = base_freq * self.odds[h]
harmonic_freqs.append(freq)
elif harm_mode == 'Skip 2':
freq = base_freq * (self.odds[h] + h)
harmonic_freqs.append(freq)
elif harm_mode == 'Skip 3':
freq = base_freq * (self.odds[h] + h + h)
harmonic_freqs.append(freq)
elif harm_mode == 'Skip 4':
freq = base_freq * (self.odds[h] + h + h + h)
harmonic_freqs.append(freq)
elif harm_mode == 'Primes':
freq = base_freq * self.primes[h]
harmonic_freqs.append(freq)
elif harm_mode == 'Sub All':
freq = base_freq / (h + 1)
harmonic_freqs.append(freq)
elif harm_mode == 'Sub Even':
freq = base_freq / (h * 2)
harmonic_freqs.append(freq)
elif harm_mode == 'Sub Odd':
freq = base_freq / self.odds[h]
harmonic_freqs.append(freq)
elif harm_mode == 'Sub Skip 2':
freq = base_freq / (self.odds[h] + h)
harmonic_freqs.append(freq)
elif harm_mode == 'Sub Skip 3':
freq = base_freq / (self.odds[h] + h + h)
harmonic_freqs.append(freq)
elif harm_mode == 'Sub Skip 4':
freq = base_freq / (self.odds[h] + h + h + h)
harmonic_freqs.append(freq)
elif harm_mode == 'Sub Primes':
freq = base_freq / self.primes[h]
harmonic_freqs.append(freq)
elif harm_mode == 'Inc 100 Hz':
freq = base_freq + (100 * h)
harmonic_freqs.append(freq)
elif harm_mode == 'Inc 250 Hz':
freq = base_freq + (250 * h)
harmonic_freqs.append(freq)
elif harm_mode == 'Inc 500 Hz':
freq = base_freq + (500 * h)
harmonic_freqs.append(freq)
elif harm_mode == 'Inc 1000 Hz':
freq = base_freq + (1000 * h)
harmonic_freqs.append(freq)
elif harm_mode == 'Random':
freq = base_freq * rnd_list[h]
harmonic_freqs.append(freq)
elif harm_mode == 'Random Hz':
freq = rnd_list_hz[h]
harmonic_freqs.append(freq)
# list with all the harmonics to be generated
harmonics = list()
# generate sine waves
for j, harm in enumerate(harmonic_freqs):
# if antialiasing enabled, check if harmonic goes beyond Nyquist and stop processing
if harm > SAMPLE_RATE / 2 and ANTIALIASING == 1:
break
print(" * Processing harmonic " + str(j+1) + ', ' + str(harm) + ' Hz')
sine = self.generate_sine(freq=harm, length=read_time / 1000, amp=MAX_AMPLITUDE, rate=SAMPLE_RATE)
# get pixel luminosity data
luminosity_values = []
x, y = seg[j].shape
for i in range(x):
R, G, B = int(seg[j][i,0]), int(seg[j][i,1]), int(seg[j][i,2])
luminosity = sqrt(0.299 * R * R + 0.587 * G * G + 0.114 * B * B) / 255
luminosity_values.append(luminosity)
# interpolate the values with the amplitude buffer
luminosity_x = linspace(0,1,len(luminosity_values))
luminosity_values = array(luminosity_values)
spl = interpolate(luminosity_x, luminosity_values, k=1, s=0)
amplitude_buff_space = linspace(0,1,(read_time / 1000) * SAMPLE_RATE)
# add the calculated harmonic to the harmonics list
harmonics.append(sine * spl(amplitude_buff_space))
# sum all harmonics in the vector
waveform = sum(harmonics)
# generate empty buffer for delay time
dly = self.generate_sine(1,delay_time / 1000, amp=0, rate=SAMPLE_RATE)
# merge the delay time with the generated waveform
rendered = append(dly,waveform)
return rendered
def _interpolate(self, x, z, **kwds):
from scipy.interpolate import NearestNDInterpolator as interpolate
return interpolate(x, z, **kwds)
def _interpolate(self, x, z, **kwds):
import numpy as np
from scipy.interpolate import Rbf as interpolate
return interpolate(*np.vstack((x.T, z)), **kwds)
from cosmo4d import lab
from cosmo4d.lab import report, dg, objectives, mapnoise, std
from abopt.algs.lbfgs import scalar as scalar_diag
from nbodykit.cosmology import Planck15, EHPower, Cosmology
from nbodykit.algorithms.fof import FOF
from nbodykit.lab import KDDensity, BigFileMesh, BigFileCatalog, ArrayCatalog, FieldMesh, FFTPower
import sys, os, json, yaml
from solve import solve
from getbiasparams import getbias, eval_bfit
sys.path.append('../')
sys.path.append('../utils/')
import HImodels
klin, plin = numpy.loadtxt('../../data/pklin_1.0000.txt', unpack=True)
ipk = interpolate(klin, plin)
#cosmo = Planck15.clone(Omega_cdm = 0.2685, h = 0.6711, Omega_b = 0.049)
cosmodef = {'omegam': 0.309167, 'h': 0.677, 'omegab': 0.048}
cosmo = Cosmology.from_dict(cosmodef)
#########################################
#Set parameters here
##
cfname = sys.argv[1]
upsample = bool(float(sys.argv[2]))
with open(cfname, 'r') as ymlfile:
cfg = yaml.load(ymlfile)
for i in cfg['basep'].keys():
locals()[i] = cfg['basep'][i]
zz = 1 / aa - 1
def _interpolate(self, x, z, **kwds):
from scipy.interpolate import NearestNDInterpolator as interpolate
return interpolate(x, z, **kwds)
def G3_proper():
psi=interpolate([0.]+psi_range, [G3]+solution.tolist())
return integratus(lambda k:K(k,0.)*psi(k),0.,L)[0]+right_side(0.)
def _create_image_interpolants(self, imsize):
vert_y, vert_x = (np.arange(limit).astype(float) for limit in imsize)
self.interp = interpolate((vert_y, vert_x), self.data,
bounds_error=False, fill_value=None) #(y,x)!
