def getGValues(self):
'''Get the G (Radius of the FOLZ) values from the calculated of the persovkite
specimen. '''
self.g_110 = np.sqrt(2*np.pi()*2*self.h_110/self.lamda)
self.g_001 = np.sqrt(2*np.pi()*2*self.h_001/self.lamda)
self.g_111 = np.sqrt(2*np.pi()*2*self.h_111/self.lamda)
return self.g_001, self.g_110, self.g_111
def getHValues(self):
'''Get the H (Reciprocial lattice plane spacing) values using the known d-spacingsof the persovkite
specimen. '''
self.h_110 = 2*np.pi()/self.spacing_110
self.h_001 = 2*np.pi()/self.spacing_001
self.h_111 = 2*np.pi()/self.spacing_111
return self.h_001, self.h_110, self.h_111
async def sys_convert(self, ctx, sysX, sysY):
if sysX == '': # checking for blank arg
await ctx.author.send(
"`***ERROR:*** You need to list the system's X coordinate.`")
elif sysY == '': # checking for blank arg
await ctx.author.send(
"`***ERROR:*** You need to list the system's Y coordinates.`")
elif type(sysX) != int: # checking for arg format
await ctx.author.send(
"`***ERROR:*** You must enter the coordinates in integer format.`"
)
elif type(sysY) != int: # checking for arg format
await ctx.author.send(
"`***ERROR:*** You must enter the coordinates in integer format.`"
)
else: # if passes checks, does calculation
if (sysX > 10.9999):
rad_part = np.pi()
if (sysY / 100 < 10.9999):
rad_part = 2 * np.pi()
else:
0
r = int(
np.around(10000 * (np.arctan(
(np.around(sysY / 100, 0) - 10.9999) /
(sysX - 10.9999)) + rad_part, 0)))
z = np.around(
np.sqrt(
np.square(sysX - 10.9999) +
np.square((sysY / 100) - 10.9999)) * 100, 0)
rad_z = str(r) + "-" + str(z)
await ctx.author.send("`The system at {}{} is {}.`").format(
sysX, sysY, rad_z)
return
def pressure_vessel(num_samples: int = 100) -> float:
"""Pressure Vessel design problem.
As found in An augmented lagrange multiplier....
Parameters
----------
x : list or ndarray
should contain 4 elements. First two should be discrete multiples or 0.0625.
Last two should be continuous.
Returns
-------
float
cost
"""
x = np.hstack((
np.random.randint(1, 10, (num_samples, 2)) * 0.0625,
np.random.random((num_samples, 2)) * 80 + 50,
))
x1 = x[0]
x2 = x[1]
x3 = x[2]
x4 = x[3]
F = (0.6224 * x1 * x3 * x4 + 1.7781 * x2 * x3 * x3 +
3.1661 * x1 * x1 * x4 + 19.84 * x1 * x1 * x3)
G = -np.pi() * x3 * x3 * x4 + (4 / 3) * np.pi() * x3 * x3 * x3 + 1296000
return (x, [F, G])
def cone(self, radius, height):
self.radius = radius
self.height = height
cone_slant = math.sqrt(radius**2 + height**2)
cone_surface_area = np.pi() * radius * (radius + cone_slant)
cone_volume = np.pi() * radius**2 * height / 3
cone_area = np.pi() * radius**2
cone_circumferance = 2 * np.pi() * radius
return f'The area of the base is {cone_area}, and the circumferance of the base is {cone_circumferance}. The surface area of the cone is {cone_surface_area}, the volume of the cone is {cone_volume}, and the slant is {cone_slant}.'
def cylinder(self, radius, height):
self.radius = radius
self.height = height
cyl_surface_area = 2 * radius * np.pi() * height + 2 * np.pi(
) * radius**2
cyl_volume = np.pi() * radius**2 * height
cyl_lateral_surface = 2 * np.pi() * radius * height
cyl_base_area = np.pi() * radius**2
cyl_diameter = 2 * radius
return f'The diameter is {cyl_diameter}, and the base area is {cyl_base_area}. The volume is {cyl_volume}, the surface area is {cyl_surface_area}, and the lateral surface is {cyl_lateral_surface}.'
def SG_PressureDensity(MBH, Mdot, r, alpha, b, rmin, m):
Omega = (GNEWT * MBH / r**3)**(-1. / 2.)
MdotPrime = Mdot * (1. - np.sqrt(rmin / r))
Teff = ((3. / (8. * np.pi())) * MdotPrime * Omega / SIGMA_THOMSON)**(1. /
4.)
def tick():
t1 = time.time()
if self._tickLast == np.nan:
self._tickLast = t1
t2 = self._tickLast
if self.flyMode:
# make camera look direction vector
a1 = self._camRot[0] * np.pi/180
a2 = self._camRot[1] * np.pi/180
x = np.cos(a1) * np.sin(a2)
y = np.sin(a1)
z = np.cos(a1) * np.cos(a2)
dt = t2 - t1
dr = self._flySpeed * dt * self._movementFwd
# move in the direction of the camera look direction
self._camPos.x += x * dr
self._camPos.y += y * dr
self._camPos.z += z * dr
# the vector to the right of the look vector
a = a2- np.pi()/2
x = np.sin(a)
y = 0
z = np.cos(a)
dr = self._flySpeed * dt * self._movementRight
self._camPos.x += x * dr
self._camPos.y += y * dr
self._camPos.z += z * dr
self.tickLast = time.time()
def coreshell_micelles(q, scale, d_head, a, b, c, rho_out, sigma, back, eta_hs, r_hs):
# A(1) = SCALE
# A(2) = D_HEAD
# A(3) = A-AXE
# A(4) = B-AXE
# A(5) = C-AXE
# A(6) = RHO_OUT
# A(7) = SIGMA
# A(8) = BACKGROUND
# A(9) = ETA_HS
# A(10) = R_HS
PI = np.pi()
NPOI = 50
STEP = 0.5 * PI / NPOI
SUM = 0
SUM1 = 0
# Graded interface factor
GRAD_O = np.exp(-q * q * sigma * sigma * 0.5)
GRAD_I = np.exp(-q * q * sigma * sigma * 0.5)
DRHO_CORE = -1
V_CORE = 4 * PI / 3 * a * b * c
V_OUT = 3 * PI / 3 * (a + d_head) * (b + d_head) * (c + d_head)
V_SHELL = V_OUT - V_CORE
DRHO_HEAD = rho_out
for III in range (1, NPOI + 1, 1):
YY = (float(III) - 0.5) * STEP
YY = sin(YY)
for II in range (1, NPOI + 1, 1):
XX = (float(II) - 0.5) * STEP
XX = sin(XX)
ARG_C = np.sqrt((a ** 2 * YY ** 2 + b ** 2 * (1-YY ** 2)) * XX** 2 + c ** 2 * (1 - XX ** 2))
ARG_O = np.sqrt(((a+d_head) ** 2 * YY ** 2 + (b + d_head) ** 2 * (1 - YY ** 2)) * XX ** 2 + (c + d_head) ** 2 * (1 - XX ** 2))
FF = V_OUT * DRHO_HEAD * FI(q * ARG_O) * GRAD_O - V_CORE * (DRHO_HEAD - DRHO_CORE) * FI(q * ARG_C) * GRAD_I
SUM = SUM + FF ** 2 ** XX
SUM1 = SUM1 + FF * XX
F0 = V_OUT * DRHO_HEAD - V_CORE * (DRHO_HEAD - DRHO_CORE)
F2 = SUM * STEP ** 2 / F0 ** 2 * 2 * PI
FFF = SUM1 * STEP ** 2 / F0 * 2 / PI
#print(q, F2, FFF, FFF ** 2)
SQ = S_HS(q, r_hs, eta_hs)
XSEC = scale * (F2 + FFF ** 2 * (SQ - 1)) + back
return XSEC
def _angle_2V(v1, v2):
a = np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
if abs(a - 1) < 1e-9:
return 0
elif abs(a + 1) < 1e-9:
return np.pi()
else:
return np.arccos(a)
def lfphase(m,n = None,w = 4):
if n is None:
n=m
arr = np.zeros((m,n))
arr[np.floor[m/2-w]:np.floor[m/2-w],np.floor[n/2-w]:np.floor[n/2-w]] = np.random.randn((2*w+1,2*w+1))
ang = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(arr)))
ang = np.real(ang)
ang = 2*np.pi(ang-np.min(ang))/(np.max(ang)-np.min(ang)-np.pi) # watch the dimensions..
ph = np.exp(1j*ang)
return ph
def get_bandwidth(data):
"""
Calculates bandwidth for the Exxx case, taken from statistics.c,
http://bonsai.hgc.jp/~mdehoon/software/python/Statistics/
"""
import numpy as np
lendata = len(data)
if lendata <= 1.0:
print("Not enough data.")
return -1.0
std = np.std(lendata)
bandwidth = std*(80/(lendata*2*(1/np.pi())**0.5)**0.2)
return bandwidth
def do_irt_mat(X_T,Xf_T,Nr,n_thetas):
from scipy import sparse
irt = sparse.lil_matrix(((2*Nr+1)**2,n_thetas*(2*Nr+1)))
for i in range(n_thetas):
lind = Xf_T[:,:,i] +1
rind = lind-1
clind = np.pi*(X_T[:,:,i]-Xf_T[:,:,i])/(n_thetas-1.)
crind = np.pi(Xf_T[:,:,i]+1-X_T[:,:,i])/(n_thetas-1.)
for j in range(2*Nr):
for js in range(2*Nr):
irt[j+(js-1)*(2*Nr+1),lind[j,js]+(i-1)*(2*Nr+1)] += clind[j,js]
irt[j+(js-1)*(2*Nr+1),rind[j,js]+(i-1)*(2*Nr+1)] += crind[j,js]
return sparse.csc_matrix(irt)
def mill_observables (N, agents, speeds):
cm, std = get_cm_std(agents, N)
mean_R = np.linalg.norm(std)
point_cm = Point(cm[0],cm[1])
norm_R = N*[0.0]
vector_R = N*[0,0]
angles = N*[0.0]
for i in range(N):
vector_R[i],norm_R[i] = relative_pos(point_cm, agents[i])
angles[i] = np.pi() - angle(vector_R[i],speeds[i])
min_R = min(norm_R)
max_R = max(norm_R)
return mean_R, min_R, max_R, angles
def __init__(self,
size=[1.0, 1.0],
ny=100,
B=0.,
theta=0.,
T=300.,
mulGrid=1):
if len(size) > 3 or len(size) < 2:
raise UserWarning("Wrong dimensions!")
size = sorted(size, reverse=True)
if len(size) > 1:
self.lx, self.ly = size[0] * 1e-0, size[1] * 1e-0
self.dim = 2
self.dx = self.ly * 1e-6 / (ny - 1)
self.nx = int(np.ceil(ny * self.lx / self.ly))
self.ny = ny
self.nz = 1
self.lz = 0.
if len(size) == 3:
if slow:
raise UserWarning(
"No 3d calculations with slow method possible!")
self.lz = size[2] * 1e-0
self.dim = 3
self.nz = int(np.ceil(ny * self.lz / self.ly))
self.u = np.zeros((self.nx, self.ny, self.nz), dtype=np.float64)
self.i = np.zeros((self.nx, self.ny, self.nz), dtype=np.float64)
t = np.cos(np.pi / self.nx) + np.cos(
np.pi / self.ny) # TODO check if really optimal solution
if self.dim == 3: t += np.cos(np.pi(self.nz))
self.wopt = (8 - np.sqrt(64 - 16 * t * t)) / t**2
self.B = B
self.theta = theta
self.T = T
self.mulGrid = mulGrid
self.currents = []
self.probes = {}
self.batches = {}
self.outputs = []
print "Initiate {}d grid with {}x{}".format(
self.dim, self.nx, self.ny) + ("x{}".format(self.nz) if self.dim
== 3 else "") + " grid points"
def mouseMoveEvent(self, ev):
if self._flyMode:
# make vector that ponts to where camera is looking
a1 = self._camRot[0] * np.pi/180
a2 = self._camRot[1]* np.pi/180
x = np.cos(a1) * np.sin(a2)
y = np.sin(a1)
z = np.cos(a1) * np.cos(a2)
v1 = QtGui.QVector3D(x, y, z)
a = a2- np.pi()/2
x = np.sin(a)
y = 0
z = np.cos(a)
rgt = QtGui.QVector3D(x, y, z)
up = QtGui.QVector3D.crossProduct(rgt, v1)
tr = QtGui.QMatrix4x4()
tr.lookAt(self._camPos, v1, up)
# v QtGui.QVector3D(x, y, z)
# tr.setToIdentity()
#
# tr.rotate(self._camPos[0], 0, 0, 1)
# tr.rotate(self._camPos[0], 0, 0, 1)
# tr.translate()
else:
if (ev.buttons() == QtCore.Qt.LeftButton
or ev.buttons() == QtCore.Qt.MidButton):
super().mouseMoveEvent(ev)
self.distanceSignal.emit(self.opts['distance'])
self.elevationSignal.emit(self.opts['elevation'])
self.azimuthSignal.emit(self.opts['azimuth'])
elif ev.buttons() == QtCore.Qt.RightButton:
diff = ev.pos() - self.mousePos
self.mousePos = ev.pos()
if not self.drawROI:
delta = (diff.x()+diff.y())*1
self.nearClip += delta
self.nearClip = max(0.01, self.nearClip)
self.setProjection()
self.nearClipSignal.emit(self.nearClip)
self.update()
def r_parallel(snapshot,
topology,
groups,
image_molecules=False,
mass_weighted=False):
import openpathsampling
import numpy
traj = openpathsampling.engines.Trajectory([snapshot
]).to_mdtraj(topology=topology)
group_definitions = [numpy.asarray(gf) for gf in groups]
atom_masses = numpy.array([aa.element.mass for aa in topology.atoms])
if mass_weighted:
masses_in_groups = [
atom_masses[aa_in_rr] for aa_in_rr in group_definitions
]
else:
masses_in_groups = [
np.ones_like(aa_in_rr) for aa_in_rr in group_definitions
]
traj_copy = traj[:]
com = []
if image_molecules:
traj_copy = traj_copy.image_molecules()
for aas, mms in zip(group_definitions, masses_in_groups):
com.append(numpy.average(traj_copy.xyz[:, aas, ], axis=1, weights=mms))
v1 = com[2] - com[0]
v2 = com[1] - com[0]
cosine = numpy.inner(v1,
v2) / (numpy.linalg.norm(v1) * numpy.linalg.norm(v2))
if (cosine >= 1):
angle = 0
elif (cosine <= -1):
angle = numpy.pi()
else:
angle = numpy.arccos(cosine)
return numpy.cos(angle) * numpy.linalg.norm(v1)
def gauss_pdf(self, X, M, S):
if M.shape[1] == 1:
DX = X - np.tile(M, X.shape[1])
E = 0.5 * np.sum(DX * (np.dot(linalg.inv(S), DX)), axis=0)
E = E + 0.5 * M.shape[0] * np.log(2 * np.pi) + 0.5 * np.log(
linalg.det(S))
P = np.exp(-E)
elif X.shape[1] == 1:
DX = np.tile(X, M.shape[1]) - M
E = 0.5 * np.sum(DX * (np.dot(linalg.inv(S), DX)), axis=0)
E = E + 0.5 * M.shape[0] * np.log(2 * np.pi) + 0.5 * np.log(
linalg.det(S))
P = np.exp(-E)
else:
DX - X - M
E = 0.5 * np.dot(DX.T, np.dot(linalg.inv(S), DX))
E = E + 0.5 * M.shape[0] * np.log(2 * np.pi()) + 0.5 * np.log(
linalg.det(S))
P = np.exp(-E)
return (P[0], E[0])
def twobodyephem(X0, t):
#TWOBODYEPHEM Produce two-body ephemeris table from time and state
#Using two-body point force, propagate from initial state through given
#time to produce ephemeris.
#INPUTS:
# X0 - Given state in inertial frame at time t. [meters, meters/seconds]
# t - State will be predicted for each point. [seconds]
mu = 3.9860044e+14
#m^3/s^2 Earth gravitational parameter
we = 2 * np.pi() / 86164
#rad/sec Earth average rotational rate
re = 6378137
#meters, spherical Earth radius
ag = 0
#Greenwich angle
[oe, T, rp, ra, f0] = rv2oe(X0, mu)
a = oe[1] #semimajor axis, meters
e = oe[2] #eccentricity
i = oe[3] #inclination, radians
Si = np.sin(i)
Ci = np.cos(i)
raan = oe[4] #%ascending node, rad
Sraan = np.sin(raan)
Craan = np.cos(raan)
w = oe[5] #aop, radians
Sw = np.sin(w)
Cw = np.cos(w)
M0 = oe[6] #mean anomaly, radians
Sm0 = np.sin(M0)
Cm0 = np.cos(M0)
n = np.sqrt(mu / a**3) #mean motion
for i in range(0, np.size(t)):
Et = keplerseqn(e, n, t[i], M0)
Mt = Et - (e * np.sin(Et))
ft = np.arccos((np.cos(Et) - e) / (1 - (e * np.cos(Et))))
oe[6] = Mt
Xt[:, i] = oe2rv(oe, ft)
def ft_sh_phase_screen(r0, N, delta, L0, l0):
D = N*delta
phz_hi = ft_phase_screen(r0, N, delta, L0, l0)
x,y = np.meshgrid(np.arange(-N/2,N/2)*delta,np.arange(-N/2,N/2)*delta)
phz_lo = np.zeros(np.size(phz_hi), np.size(phz_hi))
for p in range(1,3):
del_f = 1/(3**p*D)
fx = np.arange(-1,1)*del_f
fx,fy = np.meshgrid(fx,fx)
f,th = cart2pol(fx,fy)
fm = 5.92/10/(2*np.pi)
f0 = 1/L0
PSD_phi = 0.023*r0**(-5/3)*np.exp(-(f/fm)**2)/(f**2+f0**2)*(11/6)
PSD_phi[1,1] = 0
cn = (np.random.randn(3,3) + 1j*np.random.randn(3,3)).*np.sqrt(PSD_phi) * del_f
SH = np.zeros(N,N)
for ii in range(0,9):
SH = SH + cn(ii)*np.exp(1j*2*np.pi(fx(ii)*x+fy(ii)*y))
phz_lo = phz_lo + SH
phz_lo = np.real(phz_lo) - np.mean(np.real(phz_lo))
return phz_lo, phz_hi
def get_k(self, kmin=1e-3):
"""Get the sampled wavelengths for a spherically symmetric fourier transform
generated with trapezoidal integration.
Parameters
----------
kmin : float, optional
The smallest wavelength to sample.
Returns
-------
k : array of float
Wavelengths to sample.
Notes
-----
As this function will be used in the hnc solvers, it should be noted that
setting kmin to be too small can lead to singularity issues."""
k = np.zeros(self.rbar.shape)
k[0] = kmin
dk = np.pi(self.rbar[-1] - self.rbar[0])
for i in range(1, k.shape[0]):
k[i] = k[i - 1] + dk
return k
inplace=True,
downcast="infer",
)
print(coords_df)
theta = np.arctan2(
coords_df["headY"][args.frame_number] -
coords_df["thoraxY"][args.frame_number],
coords_df["headX"][args.frame_number] -
coords_df["thoraxX"][args.frame_number],
)
print(f"\nCurrent frame theta: {theta}")
angular_resolution = 100
thetas_to_check = np.linspace(theta,
theta + 2 * np.pi(),
num=angular_resolution,
endpoint=False)
cross_cor = np.zeros((max_shift, angular_resolution))
angular_index = -1
for current_theta in thetas_to_check:
angular_index += 1
# Convert coordinates
cX_array = coords_df["cX"].to_numpy()
cY_array = coords_df["cY"].to_numpy()
cX_array = cX_array * np.cos(theta) # Forward-facing
cY_array = cY_array * np.cos(theta) # Side-facing
max_shift = 1000
def coherence(self):
return np.sin(2 * np.pi(self.value - self.value.mean()) +
np.pi / 2).mean()
def reflectance ( file, Temp='None' ):
from netCDF4 import Dataset
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.basemap import Basemap
import datetime
plt.close("all")
#VIS DEFS
mVIS=0.6118208
kVIS=0.001160
X0=29.0
C=1.255 # For FEB2013
tz=-4 #For Manaus
RadVISUnits='Radiance [W/(m2 sr um)]'
RefVISUnits='Reflectance'
#IR DEFS
m2=227.3889
m3=38.8383
m4=5.2285
m6=5.5297
bb2=68.2167
bb3=29.1287
bb4=15.6854
bb6=16.5892
RadIRUnits='Radiance [mW/(m2 sr cm-1)]'
TUnits='Brightness Temperature [K]'
C1=1.191066e-5 # mW/(m2 sr cm-4)
C2=1.438833 # K/(cm-1)
n2=2561.7421
n3=1522.5182
n4=937.23449
n6=749.82589
a2=-1.4755462
a3=-4.1556932
a4=-0.52227011
a6=-0.16089410
b2=1.0028656
b3=1.0142082
b4=1.0023802
b6=1.0006896
g2=-5.8203946e-7
g3=-8.0255086e-6
g4=-2.0798856e-6
g6=-3.9853774e-7
band=file.split('.')[4]
procmode='IR'
if band == 'BAND_01':
procmode = 'VIS'
#if time < 09 UTC, do not process night time in Manaus - TBD
print 'Reading: ', file
print 'Mode: ', procmode
fh = Dataset(file, mode='r')
lons = fh.variables['lon'][:]
lats = fh.variables['lat'][:]
datas = fh.variables['data'][:]
fh.close()
fn=file.split('/')
fn=fn[len(fn)-1][:-3]+'-'+type+'.png'
year=fn.split('.')[1]
julian=fn.split('.')[2]
hhmm=fn.split('.')[3]
h=datetime.datetime(int(year), 1, 1) + datetime.timedelta(int(julian) - 1)
# Get some parameters for the Geostationary map projection
f=plt.figure(facecolor='Black')
f.set_size_inches(7,6,forward='True')
ax = f.add_axes([0,0,1,1])
m = Basemap(resolution='h',projection='geos', lon_0=-75,lat_0=0, llcrnrlat=-5.98,llcrnrlon=-63.0,urcrnrlon=-57.0,urcrnrlat=0.0)
lon, lat = lons, lats
xi, yi = m(lon, lat)
#Convert 16bit to 10bit
Raw=datas/32.
RawUnits='Counts'
# Data processing for VIS channel
if procmode == 'VIS':
date=datetime.date(h.year,h.month,h.day)
time=datetime.time(int(hhmm[:-4]),int(hhmm[2:-2]),int(hhmm[4:]))
RefPre=kVIS*(Raw-X0)
RefVIS=RefPre * C
SZA, SED = sunzen(date, time, tz, lat, lon)
RefVIS=RefVIS*(SED*SED/np.cos(np.deg2rad(SZA)))
cs = RefVIS
# Data processing for IR
if procmode == 'IR':
RadIR=(Raw - bb2)/m2
Emission = Planck(Temperature=Temp,wavelength=3.90)
RefIR = (RadIR - Emission)/((t0 * F0 * mu0 / np.pi())- Emission)
cs = RefIR
return, cs
elif e_norm < 1:
print("a. It is an elliptical orbit")
print("e is " + str(e_norm))
elif e_norm == 1:
print("a. It is a parabolic orbit")
print("e is " + str(e_norm))
elif e_norm > 1:
print("a. It is a hyperbolic orbit")
print("e is " + str(e_norm))
# b
h_norm = lg.norm(h)
k = (h_norm**2) / (r_0_norm * MU) - 1
theta_0 = np.arccos(k / e_norm) # anomaly at initial condition
if np.dot(r_0, v_0) < 0:
theta_0 = 2 * np.pi() - theta_0
print("b. Anomaly at t_0 is " + str(theta_0))
E_0 = 2 * math.atan2(
np.sqrt(1 - e_norm) * np.tan(theta_0 / 2), np.sqrt((1 + e_norm)))
print("Eccentric Anomaly at t_0 is: " + str(E_0))
M_E_0 = E_0 - e_norm * np.sin(E_0)
print("Mean Anomaly at t_0 is: " + str(M_E_0))
# c
a = (r_0_norm * (1 + e_norm * np.cos(theta_0))) / (1 - e_norm * e_norm)
n = np.sqrt(MU / a**3)
t_p = -M_E_0 / n
print("c. t_p is: " + str(t_p))
# d
t = np.linspace(0, 40000, 81)
v[0:N] = q[0] / a[0]
Q[0] = q
Y[0] = y
A[0] = a
V[0] = v
#Seccion 3
t = 0
k = 0
while t < Tfin:
k += 1
dt = NC * dx / V[k]
t += dt
if t <= 150 * 60:
Q[k + 1,
0] = 250 + 750 / (np.pi() * (1 - np.cos(np.pi() * t / (60 * 75))))
else:
Q[k + 1, 0] = 250
y = NRalpha(Q[k + 1, 1], B, ss, n, Co, S)
A[k + 1, 1] = y[0]
Y[k + 1, 1] = y[1]
V[k + 1, 1] = Q[k + 1, 1] / A[k + 1, 1]
for i in range(N - 1):
Q[k + 1, i + 1] = Q[k + 1, i] - dt / dx * (A[k + 1, i] - A[k, i])
z = NRalpha(Q[k + 1, i + 1], B, ss, n, Co, S)
A[k + 1, i + 1] = z[0]
Y[k + 1, i + 1] = z[1]
V[k + 1, i + 1] = Q[k + 1, i + 1] / A[k + 1, i + 1]
def ir_stick_spectrum_compute(omega,eigenvalues,Iir1modeAbs):
q = []
for i in range(0,len(Iir1modeAbs)):
q.append((Iir1modeAbs[i]*Gamma_IR_Sticks/np.pi())/((omega - eigenvalues[i]-Omega_offset_IR)**2+Gamma_IR_Sticks**2))
IR_Stick_Spectrum_Omega = sum(q)
return IR_Stick_Spectrum_Omega
import numpy as np
import numpy.linalg as lg
MU = 1 # DU^3/TU^2
r = [-1.2, 1.5, 0]
v = [0, 0, .922]
h = np.cross(r, v)
print("The momentum vector is: " + str(h) + "DU^2/TU")
v_norm = lg.norm(v)
r_norm = lg.norm(r)
eps = (v_norm * v_norm) / 2 - MU / r_norm
print("Total Energy is: " + str(eps))
e = np.cross(v, h) / MU - np.divide(r, r_norm)
print("Eccentricity vector is: " + str(e))
e_norm = lg.norm(e)
h_norm = lg.norm(h)
k = (h_norm * h_norm) / r_norm - 1
theta = np.arccos(k / e_norm)
if np.dot(r, v) < 0:
theta = 2 * np.pi() - theta
print("Anomaly is: " + str(theta))
print("The magnitude of the eccentricity is: " + str(e_norm))
a = (r_norm * (1 + e_norm * np.cos(theta))) / (1 - e_norm * e_norm)
print("Semi-major axis length: " + str(a))
r_p = a * (1 - e_norm)
print("Periapsis length: " + str(r_p))
r_a = a * (1 + e_norm)
print("Apoapsis length: " + str(r_a))
X = np.concatenate((x, y))
X += amplitude * np.random.randn(2, X, shape[1])
return X.T
def get_rose(t, noise_amplitude=0.02):
k = 5
r = np.cos(k * t) + 0.25
x = r * np.cos(t)
y = r * np.sin(t)
return add_noise(x, y, noise_amplitude)
def get_hypotrochoid(t, noise_amplitude=0):
a, b, h = 10.0, 2.0, 4.0
x = (a - b) * np.cos(t) + h * np.cos((a - b) / b * t)
y = (a - b) * np.sin(t) + h * np.sin((a - b) / b * t)
return add_noise(x, y, 0)
if __name__ == '__main__':
n_samples = 500
np.random.seed(2)
t = 2.5 * np.pi(1 + 2 * np.random.rand(1, n_samples))
x = get_spiral(t)
connectivity = None
perform_clustering(x, connectivity, 'No Connectivity')
connectivity = kneighbors_graph(x, 10, include_self=False)
perform_clustering(x, connectivity, 'KNN Connectivity')
plt.show()
def area_to_width(total, max_width):
return np.sqrt(total / np.pi())
import numpy as np
#coverage calculation:
#assume the earth is a sphere (approximation)
#AltitudeFromCentre is distance from object being tracked to centre of earth
#unitary. Just add constants and stir for coverage satisfaction
val = input(
'enter altitude in earth radii (note, earth radius here is normalised)')
Altitude = float(val)
EarthRadius = 1
AltitudeFromCentre = Altitude + EarthRadius
#theta: angle between vector:centre to object and vector: object to coverage limit
thetaA = np.arcsin(EarthRadius / AltitudeFromCentre)
#DistToLimit: distance to coverage limit from the object (symmetrical through theta in spherical approximation)
DistToLimit = EarthRadius / np.tan(theta)
#PolarAxisToSurface: distance between z axis and a point lying on the coverage limit
PolarAxisToSurface = DistToLimit * np.sin(theta)
#DistToAltitude: distance from the origin of PolarAxisToSurface and the object
DistToAltitude = np.sqrt((PolarAxisToSurface**2) + (DistToLimit**2))
#coverage: the coverage radius that defines the area of coverage (line of sight)
coverage = 2 * np.pi() * theta / 360
print('distance to ')
def rv2oe(rv, mu):
#RV2OE Convert from position and velocity to orbital elements
#Given a known gravitational parameter for a planet, an artificial satellit
#e initial state is provided in a nonrotating coordinate system.
rholder = rv[0:3]
vholder = rv[3:6]
del rv
rv = np.vstack((rholder, vholder))
#magnitudes
rmag = np.linalg.norm(rholder) #m
vmag = np.linalg.norm(vholder) #m/s
#specific angular momentum
h = np.cross(rholder, vholder) #m^2/s
hmag = np.linalg.norm(h)
#inclination
i = np.arccos(h[2] / hmag) #rad
#raan
hxy = np.sqrt(h[0]**2 + h[1]**2)
sinraan = h[0] / hxy
cosraan = -h[1] / hxy
raan = np.arctan2(sinraan, cosraan)
#specific energy per unit mass
energy = ((vmag**2) / 2) - (mu / rmag)
#semimajor axis
a = -mu / (2 * energy)
#eccentricity
e = np.sqrt(1 + ((2 * energy * hmag**2) / mu**2))
evec = np.cross(vholder, (h / mu)) - rholder / rmag
#semiminor axis
b = a * np.sqrt(1 - e**2)
#semi-latus rectum
p = a * (1 - e**2)
#true anomaly
if np.dot(rholder, vholder) < 0:
f = (2 * np.pi() - np.arccos(np.dot(evec, rholder) / (e * rmag)))
else:
f = np.arccos(np.dot(evec, rholder) / (e * rmag))
#perifocus
sinwf = rholder[2] / (rmag * np.sin(i))
coswf = ((rholder[0] / rmag) * np.cos(raan)) + (
(rholder[1] / rmag) * sin(raan))
wf = np.arctan2(sinwf, coswf)
w = wf - f
#eccentric anomaly
cosE0 = ((rmag / a) * np.cos(f)) + e
sinE0 = ((rmag / b) * np.sin(f))
E0 = np.arctan2(sinE0, cosE0)
#Mean Anomaly
M0 = E0 - e * np.sin(E0)
#Period
T = 2 * np.pi() * np.sqrt(a**3 / mu)
rp = a * (1 - e)
ra = a * (1 + e)
oe = np.array([a, e, i, raan, w, M0])
return oe, T, rp, ra, f
def fit_tooth_data(data_fname, model_fname='equalsize_jul2015a.h5', **kwargs):
print 'importing isotope data...'
data_isomap, isomap_shape, isomap_data_x_ct = load_iso_data(data_fname)
print 'loading tooth model ...'
tooth_model = ToothModel(model_fname)
fit_kwargs = kwargs.copy()
# M1-M2 conversion parameters
m2_m1_params = np.array([67.974, 0.003352, -25.414, 41., 21.820, .007889, 29.118, 35.]) # 'synch86', outlier, 100k
#m2_m1_params = np.array([78.940, 0.003379, -49.708, 41., 21.820, .007889, 29.118, 35.]) # 'synch86', outliers, 100k
m1_m2_params = np.array([21.820, .007889, 29.118, 35., 67.974, 0.003352, -25.414, 41.]) # 'synch86', outlier, 100k
#m1_m2_params = np.array([21.820, .007889, 29.118, 35., 78.940, 0.003379, -49.708, 41.]) # 'synch86', outliers, 100k
# Real climate data
#month_d180 = np.array([-1.95, -1.92, -2.94, -3.44, -2.22, -1.10, -0.67, -1.71, -0.81, -1.47, -2.31, -3.19]) # Dar Es Salaam
#month_d180 = np.array([-0.21, 0.30, -0.04, 0.25, -0.75, -0.19, -3.16, -4.53, -0.95, 0.29, -1.26, -1.73]) # Addis Ababa
#month_d180 = np.array([-1.39, -0.35, -2.42, -3.25, -3.08, -1.44, -0.98, -1.88, -1.33, -3.10, -3.80, -1.63]) # Entebbe, Uganda
#month_d180 = np.array([-6.31, -7.09, -4.87, -3.33, -1.83, -1.22, -1.08, -0.47, -0.17, -0.48, -2.92, -5.90]) # Harare, Zimbabwe
#month_d180 = np.array([-2.98, -2.20, -4.74, -5.94, -2.64, -3.80, -0.25, -1.80, -1.25, -4.15, -5.80, -5.42]) # Kinshasa, DRC
#month_d180 = np.array([-1.58, -1.54, -1.81, -3.08, -3.40, -3.69, -3.38, -3.78, -2.46, -2.19, -2.12, -1.79]) # Cape Town
#month_d180 = np.array([-4.31, -3.50, -4.14, -4.68, -4.87, -5.11, -4.77, -4.80, -4.71, -4.50, -4.53, -4.77]) # Marion Island
#month_d180 = np.array([0.00, -2.40, -1.75, -3.70, -3.90, -6.20, -7.75, -8.10, -6.25, -3.30, -4.75, -8.95, -2.10, -0.40, -4.55, -3.25, -5.75, -3.70, -8.60, -7.10, -8.50, -5.30, -4.55, -3.10, -2.75 -4.60, -2.00, -3.10, -5.25, -6.10]) # Hong Kong
#month_d180 = np.array([-2.75, -5.35, -2.70, -1.60, -6.30, -7.25, -9.00, -8.10, -9.50, -5.30, -5.75, -4.00]) # Liuzhou
#month_d180 = np.array([-5.30, -4.73, -7.44, -4.38, -4.39, -7.07, -9.76, -3.99, -3.95, -5.81, -8.98, -9.89, -8.62, -8.88, -8.25, -8.21, -9.74, -6.83, -6.69, -6.38, -10.33, -7.95, -5.72, -10.52, -10.74, -7.48, -9.30, -8.50, -12.66, -10.52, -10.82, -6.01, -8.34, -5.51, -7.03, -5.75, -8.14, -6.85, -4.82, -7.31, -8.79, -4.77, -6.14, -2.96, -2.31, -5.13, -9.31, -8.88, -9.22, -9.08, -7.51, -7.72, -10.29, -10.38, -9.69, -8.64, -10.66, -7.85, -6.94]) # Mulu, Borneo
#week_d180 = np.array([-19.40, -19.4, -19.4, -19.4, -15.9, -15.9, -15.9, -23.1, -23.1, -23.1, -23.1, -23.1, -23.1, -23.1, -16.5, -16.5, -8.8, -8.8, -10.6, -10.6, -2.5, -9.3, -6.7, -8.2, -1.6, -6, -7, -4.4, -8.8, -6.5, -6.1, -6.1, -6.1, -0.6, 1.7, -4.5, -4.5, -4.5, -12.4, -12.4, -9.7, -12.2, -12.2, -12.2, -15.1, -15.1, -11, -11, -11, -30.5, -30.5, -30.5]) # North Platte Nebraska
month_d180 = np.array([-18.50, -17.93, -12.16, -12.08, -6.88, -7.00, -7.49, -5.60, -8.87, -13.91, -14.20, -23.70]) # North Platte, Nebraska
# Synthetic data testing
daily_d18O_180 = 10.*np.sin((2*np.pi()/180.)*(np.arange(550.)))-11.
daily_d18O_090 = 10.*np.sin((2*np.pi()/90.)*(np.arange(550.)))-11.
daily_d18O_045 = 10.*np.sin((2*np.pi()/45.)*(np.arange(550.)))-11.
# Conversion monthly precipitation isotope record into daily record
year_iso_days = np.arange((24))*(730./(24.)) + 100.
m1_iso_days = tooth_timing_convert(year_iso_days, *m2_m1_params)
m1_iso_days -= (0. + m1_iso_days[0])
w_iso_hist = np.ones(400)
month_d180 = np.concatenate((month_d180, month_d180))
month_d180 = np.concatenate((month_d180, month_d180))
for k,d in enumerate(m1_iso_days):
d = int(d)
w_iso_hist[d:] = month_d180[k+11]
water_spl, blood_spl, days_spl, i33_spl, i50_spl, i66_spl = spline_input_signal(1)
water_spl = water_spl[50:]
blood_spl = blood_spl[50:]
days_spl = days_spl[50:]
i33_spl = i33_spl[50:]
i50_spl = i50_spl[50:]
i66_spl = i66_spl[50:]
m1_days_spl = tooth_timing_convert(days_spl, *m2_m1_params)
water_spl_tmp = np.ones(days_spl.size)
blood_spl_tmp = np.ones(days_spl.size)
i33_spl_tmp = np.ones(days_spl.size)
i50_spl_tmp = np.ones(days_spl.size)
i66_spl_tmp = np.ones(days_spl.size)
print i33_spl.size, i33_spl_tmp.size, water_spl_tmp.size, m1_days_spl.size
for k,d in enumerate(m1_days_spl):
d = int(d)
water_spl_tmp[d:] = water_spl[k]
blood_spl_tmp[d:] = blood_spl[k]
i33_spl_tmp[d:] = i33_spl[k]
i50_spl_tmp[d:] = i50_spl[k]
i66_spl_tmp[d:] = i66_spl[k]
water_spl = water_spl_tmp
blood_spl = blood_spl_tmp
i33_spl = i33_spl_tmp
i50_spl = i50_spl_tmp
i66_spl = i66_spl_tmp
# Full model loading and isomap
#fit_kwargs['tooth_model'] = tooth_model
#model_isomap_full = water_hist_likelihood_fl(w_iso_hist, **fit_kwargs)
#model_isomap_full = np.array(model_isomap_full)
#mu_fl = np.median(model_isomap_full, axis=0)
# Small tooth model generation
tooth_model_sm = tooth_model.downsample_model((isomap_shape[0]+5, isomap_shape[1]+5), 1)
# Set keyword arguments to be used in fitting procedure
fit_kwargs['tooth_model'] = tooth_model_sm
fit_kwargs['data_isomap'] = data_isomap
fit_kwargs['isomap_shape'] = isomap_shape
fit_kwargs['isomap_data_x_ct'] = isomap_data_x_ct
# Generate blood d18O and tooth d18O isomap from drinking water history, with score compared to measured data
score_sm_w, model_isomap_sm_w = water_hist_likelihood(water_spl, **fit_kwargs)
score_i33, model_isomap_i33 = water_hist_likelihood(i33_spl, **fit_kwargs)
score_i50, model_isomap_i50 = water_hist_likelihood(i50_spl, **fit_kwargs)
score_i66, model_isomap_i66 = water_hist_likelihood(i66_spl, **fit_kwargs)
mu_sm_w = np.median(model_isomap_sm_w, axis=2)
sigma_sm_w = np.std(model_isomap_sm_w, axis=2)
sigma_sm_w = np.sqrt(sigma_sm_w**2. + 0.15**2 + 0.05**2)
#resid_img = (mu - data_isomap) / sigma
# Generate tooth isomap from blood measurements
forward_metabolic_kw = kwargs.get('metabolic_kw', {})
forward_phosphate_eq_b_PO4 = PO4_dissoln_reprecip(3., 34.5, .3, blood_spl, **kwargs)
forward_blood_model = gen_isomaps(isomap_shape, isomap_data_x_ct, tooth_model_sm, forward_phosphate_eq_b_PO4) # This takes the blood history from 962 scaled to the M1 without also downscaling the blood turnover
plt.plot(m1_days_spl, water_spl, 'b', lw=2)
plt.plot(m1_days_spl, blood_spl, 'r', lw=2)
plt.plot(m1_days_spl, forward_phosphate_eq_b_PO4, 'g', lw=2)
plt.show()
m_mu_sm = np.ma.masked_array(mu_sm_w, np.isnan(mu_sm_w))
mu_sm_r = np.mean(m_mu_sm, axis=1)
small_sample = np.ones(int(mu_sm_r.size/2))
for k,d in enumerate(small_sample):
small_sample[k] = (mu_sm_r[(k*2)]+mu_sm_r[(k*2)+1])/2
mu_sm_r = small_sample
mu_sm_r.shape = (mu_sm_r.size, 1)
print mu_sm_r.shape
# Save generated isomap as CSV file
#save_tooth = mu_sm.T
#save_tooth[np.isnan(save_tooth)] = 0.
#np.savetxt('m2_predicted_a_hist_half=3.csv', np.flipud(save_tooth), delimiter=',', fmt='%.2f')
mu_sm_w[mu_sm_w==0.] = np.nan
print score_sm_w
textstr = '%.1f' % score_sm_w
fig = plt.figure(figsize=(10,4), dpi=100)
#ax1 = fig.add_subplot(3,1,1)
#cimg1 = ax1.imshow(mu_fl.T, aspect='auto', interpolation='nearest', origin='lower', vmin=16., vmax=17., cmap='bwr')
#cax1 = fig.colorbar(cimg1)
ax1 = fig.add_subplot(6,1,1)
ax1text = 'forward model from water data 100% ice'
ax1.text(19, 3, ax1text, fontsize=8)
cimg1 = ax1.imshow(mu_sm_w.T, aspect='equal', interpolation='nearest', origin='lower', vmin=9., vmax=15., cmap='bwr')
cax1 = fig.colorbar(cimg1)
ax2 = fig.add_subplot(6,1,2)
ax2text = 'data'
ax2.text(19, 3, ax2text, fontsize=8)
cimg2 = ax2.imshow(data_isomap.T, aspect='equal', interpolation='nearest', origin='lower', vmin=9., vmax=15., cmap='bwr')
cax2 = fig.colorbar(cimg2)
ax3 = fig.add_subplot(6,1,3)
ax3text = 'forward model from blood data'
ax3.text(19, 3, ax3text, fontsize=8)
cimg3 = ax3.imshow(np.mean(forward_blood_model, axis=2).T, aspect='equal', interpolation='nearest', origin='lower', vmin=9., vmax=15., cmap='bwr')
cax3 = fig.colorbar(cimg3)
ax4 = fig.add_subplot(6,1,4)
ax4text = 'forward model 33% ice'
ax4.text(19, 3, ax4text, fontsize=8)
cimg4 = ax4.imshow(np.mean(model_isomap_i33, axis=2).T, aspect='equal', interpolation='nearest', origin='lower', vmin=9., vmax=15., cmap='bwr')
cax4 = fig.colorbar(cimg4)
ax5 = fig.add_subplot(6,1,5)
ax5text = 'forward model 50% ice'
ax5.text(19, 3, ax5text, fontsize=8)
cimg5 = ax5.imshow(np.mean(model_isomap_i50, axis=2).T, aspect='equal', interpolation='nearest', origin='lower', vmin=9., vmax=15., cmap='bwr')
cax5 = fig.colorbar(cimg5)
ax6 = fig.add_subplot(6,1,6)
ax6text = 'forward model 66% ice'
ax6.text(19, 3, ax6text, fontsize=8)
cimg6 = ax6.imshow(np.mean(model_isomap_i66, axis=2).T, aspect='equal', interpolation='nearest', origin='lower', vmin=9., vmax=15., cmap='bwr')
cax6 = fig.colorbar(cimg6)
t_save = time()
fig.savefig('spline_water_snow_2015_11_14_18p6_w_ice_blood_w_PO4.svg'.format(t_save), dpi=300)
plt.show()
'''
def Nline(x):
#Derivative of normal cumulative distribution function
NDer = (1 / math.np.sqrt(2 * np.pi())) * np.exp(-(x ^ 2) / 2)
return NDer
