def generateIonizationElectronData(E):
vel = c * (1 - ((E / (eMass * c**2)) + 1)**(-2))**.5
k = (2 * np.pi * TC._eCharge / (TC._eMass * vel * vel))
omega = lambda gamma: -2 * (E - gamma) + (2 * E * (2 * E - gamma))**.5
F = lambda a, b: a + b
s = lambda a: (1 - 2 * a)**.5
phi = lambda gamma: 1
f = lambda gamma: 1
M1 = lambda a, b: (np.log(
((b - a) * (1 - b + a) * (1 + a - s(a)) * (1 - a + s(a))) /
(b * (1 - b) * (1 - a - s(a)) *
(1 + a + s(a)))) / a) + (2 / (1 + a)) * (sci.special.ellipkinc(
np.asin((1 + a - 2 * b) / (1 - a)),
((1 - a) /
(1 + a))) - sci.special.ellipkinc(np.asin((s(a)) / (1 - a)),
((1 - a) / (1 + a))))
M2 = lambda a, b: (np.log(
((b - a) * (1 - b + a)) /
(b * (1 - b))) / a) + (2 / (1 + a)) * (sci.special.ellipkinc(
np.asin((1 + a - 2 * b) / (1 - a)), ((1 - a) / (1 + a))))
L = lambda a: (np.log(((1 + a - s(a)) * (1 - a + s(a))) / (
(1 - a - s(a)) *
(1 + a + s(a)))) / a) - (2 / (1 + a)) * (sci.special.ellipkinc(
np.asin((s(a)) / (1 - a)), ((1 - a) / (1 + a))))
MeanFreeIon = lambda gamma: k * f(gamma) * phi(gamma) * L(gamma / E) / E
ion1 = lambda gamma: k * f(gamma) * phi(gamma) * M1()
# print(M1(3,4))
return
def foo(d):
ng = 1.56
dn = 0.2
no = (dn + 2*sqrt(-2*dn**2 + 9*ng**2))/6. - dn/2
ne = (dn + 2*sqrt(-2*dn**2 + 9*ng**2))/6. + dn/2
alpha = rad2deg(asin(1/ng*sin(deg2rad(20))))/2;
wl0 = 940e-9
k0 = 2*pi/wl0
Kx = -2*k0*ng*sin(deg2rad(alpha))*cos(deg2rad(alpha))
Kz = -2*k0*ng*sin(deg2rad(alpha))*sin(deg2rad(alpha))
px = 2*pi/Kx
pz = 2*pi/Kz
thetas = np.linspace(-40, 40, 41)
DERl = []
DERr = []
DETl = []
DETr = []
nn = 1
lays = genGradient(PVG2, 10, 15e-6 , px, pz*2., pz*0.5, -1, no, ne)
for theta in thetas:
thetai = rad2deg(asin(sin(deg2rad(theta))/ng))
rcwa = RCWA(ng, ng, lays, nn, [1, 1j], [1j, 1])
derl, derr, detl, detr = rcwa.solve(0, thetai, wl0, 1, 1j)
DETr.append(detr)
DETr = array(DETr).T
loss = np.sum(np.abs(DETr[nn-1]-1))
return loss
def beta(self,m1,d,g=1.4,i=0):
p=-(m1*m1+2.)/m1/m1-g*np.sin(d)*np.sin(d)
q=(2.*m1*m1+1.)/ np.pow(m1,4.)+((g+1.)*(g+1.)/4.+
(g-1.)/m1/m1)*np.sin(d)*np.sin(d)
r=-np.cos(d)*np.cos(d)/np.pow(m1,4.)
a=(3.*q-p*p)/3.
b=(2.*p*p*p-9.*p*q+27.*r)/27.
test=b*b/4.+a*a*a/27.
if (test>0.0):
return -1.0
elif (test==0.0):
x1=np.sqrt(-a/3.)
x2=x1
x3=2.*x1
if(b>0.0):
x1*=-1.
x2*=-1.
x3*=-1.
if(test<0.0):
phi=np.acos(np.sqrt(-27.*b*b/4./a/a/a))
x1=2.*np.sqrt(-a/3.)*np.cos(phi/3.)
x2=2.*np.sqrt(-a/3.)*np.cos(phi/3.+np.pi*2./3.)
x3=2.*np.sqrt(-a/3.)*np.cos(phi/3.+np.pi*4./3.)
if(b>0.0):
x1*=-1.
x2*=-1.
x3*=-1.
s1=x1-p/3.
s2=x2-p/3.
s3=x3-p/3.
if(s1<s2 and s1<s3):
t1=s2
t2=s3
elif(s2<s1 and s2<s3):
t1=s1
t2=s3
else:
t1=s1
t2=s2
b1=np.asin(np.sqrt(t1))
b2=np.asin(np.sqrt(t2))
betas=b1
betaw=b2
if(b2>b1):
betas=b2
betaw=b1
if(i==0):
return betaw
if(i==1):
return betas
def plotLensDistance(h):
r = 0.15
n1 = 1
n2 = 1.5
# h = np.linspace(0, 0.05, 2000)
a2= asin(n1/n2 * h/r)
a1= asin(h/r)
df = r*sin(a2)/sin(a1-a2)
dx = r+df
plt.plot(h,dx, "b")
def plotChromaticAbb(h, n2):
r = 0.15
n1 = 1
# n2 = 1.5
# h = np.linspace(0, 0.05, 2000)
a2= asin(n1/n2 * h/r)
a1= asin(h/r)
df = r*sin(a2)/sin(a1-a2)
dx = r+df
# plt.plot(n2,dx, "b")
return dx
def distance_haversine(a):
"""
Calculate the great circle distance between two lists of
latitudes and longitudes of points
on the earth (specified in decimal degrees).
Haversine
formula:
a = sin²(Δφ/2) + cos φ1 ⋅ cos φ2 ⋅ sin²(Δλ/2)
c = 2 ⋅ atan2( √a, √(1−a) )
d = R ⋅ c
where φ is latitude, λ is longitude, R is earth’s radius (mean radius = 6,371km);
note that angles need to be in radians to pass to trig functions!
"""
lat, lon = a
for p in zip(lat, lon):
valpoint(p)
R = 6371 # km - earths's radius
# convert decimal degrees to radians
lat, lon = map(np.radians, [lat, lon])
# haversine formula
dlon, dlat = np.diff(lon), np.diff(lat)
print(dlon)
np.insert(dlon, 0)
np.insert(dlat, 0)
f = np.sin(dlat/2)**2 + np.cos(lat) * np.cos(lat) * np.sin(dlon/2)**2
c = 2 * np.asin(np.sqrt(f)) # 2 * np.atan2(np.sqrt(f), np.sqrt(1-f))
d = R * c
return d
def __call__(self, photon):
"""Returns the reflectivity of the coating for the incident photon."""
if isinstance(self.reflectivity, Spectrum):
return self.reflectivity.value(photon.wavelength)
elif isinstance(self.reflectivity, AngularSpectrum):
# DJF 8/5/2010
#
# The internal incident angle (substate-coating) will not correspond to the same value of
# reflectivity as for the same angle and the external interface (air-coatings) because the
# refraction angle into the material will be different. We need to apply a correction factor
# to account for this effect (see Farrell PhD Thesis, p.129, 2009)
#
# If the previous containing object's (i.e. this will be the substate for an internal
# collision, or air if an external collision) has a refractive index higher than air
# (n_air = photon.scene.bounds.material.refractive_index) then the correction is applied,
# else the photon must be heading into an external interface and no correction is needed.
#
if photon.previous_container.material.refractive_index > photon.scene.bounds.material.refractive_index:
# Hitting internal interface, therefore apply correction to angle
n_substrate = photon.previous_container.material.refractive_index
n_environment = photon.scene.bounds.material.refractive_index
rads = np.asin(n_substrate/n_environment * sin( angle(normal, photon.direction) ))
else:
rads = angle(normal, photon.direction)
return self.reflectivity.value(photon.wavelength, rads)
else:
# Assume it's a number
return self.reflectivity
def deflections(self, xin, yin):
from numpy import ones, arctan as atan, arctanh as atanh
from math import cos, sin, pi
from numpy import arcsin as asin, arcsinh as asinh
x, y = self.align_coords(xin, yin)
q = self.q
if q == 1.:
q = 1. - 1e-7 # Avoid divide-by-zero errors
eps = (1. - q**2)**0.5
if self.eta == 1.:
# SIE models
r = (x**2 + y**2)**0.5
r[r == 0.] = 1e-9
xout = self.b * asinh(eps * x / q / r) * q**0.5 / eps
yout = self.b * asin(eps * y / r) * q**0.5 / eps
else:
from powerlaw import powerlawdeflections as pld
b, eta = self.b, self.eta
s = 1e-7
if x.ndim > 1:
yout, xout = pld(-1 * y.ravel(), x.ravel(), b, eta, s, q)
xout, yout = xout.reshape(x.shape), -1 * yout.reshape(y.shape)
else:
yout, xout = pld(-1 * y, x, b, eta, s, q)
yout = -1 * yout
theta = -(self.theta - pi / 2.)
ctheta = cos(theta)
stheta = sin(theta)
x = xout * ctheta + yout * stheta
y = yout * ctheta - xout * stheta
return x, y
def angle(q, wavelength):
'''
calculate angle given Q and wavelength
q - wavevector (A^-1)
wavelength - wavelength of radiation (Angstrom)
'''
return np.asin(q / 4. / np.pi * wavelength) * 180 / np.pi
def __call__(self, photon):
"""Returns the reflectivity of the coating for the incident photon."""
if isinstance(self.reflectivity, Spectrum):
return self.reflectivity.value(photon.wavelength)
elif isinstance(self.reflectivity, AngularSpectrum):
# DJF 8/5/2010
#
# The internal incident angle (substate-coating) will not correspond to the same value of
# reflectivity as for the same angle and the external interface (air-coatings) because the
# refraction angle into the material will be different. We need to apply a correction factor
# to account for this effect (see Farrell PhD Thesis, p.129, 2009)
#
# If the previous containing object's (i.e. this will be the substate for an internal
# collision, or air if an external collision) has a refractive index higher than air
# (n_air = photon.scene.bounds.material.refractive_index) then the correction is applied,
# else the photon must be heading into an external interface and no correction is needed.
#
if photon.previous_container.material.refractive_index > photon.scene.bounds.material.refractive_index:
# Hitting internal interface, therefore apply correction to angle
n_substrate = photon.previous_container.material.refractive_index
n_environment = photon.scene.bounds.material.refractive_index
rads = np.asin(n_substrate / n_environment *
sin(angle(normal, photon.direction)))
else:
rads = angle(normal, photon.direction)
return self.reflectivity.value(photon.wavelength, rads)
else:
# Assume it's a number
return self.reflectivity
def pixel2A(self, position = None):
"""
Convert pixel index to wavelength
(This works only for the Si CCD already installed on the spectrometer.)
:param position: Position of the spectrometer (Angtroms). If omited, use current one.
:type position: float
:returns: Wavelength of each pixels
:rtype: numpy array
"""
if position is None:
position = self._query('posi?')
# Parametres prit integralement de la version Matlab
# dv = 2.341131e-001;
# fact = 1.812402816604375e-004;
# Parametres ajustes sur des mesures sur le pic Ne @ 6929.4673
dv = 0.19583658
fact = 1.812402816604375e-004 # Fixe
dispersion = 1e7 / 3.6e6 * np.cos(np.asin(fact*position/2)+dv/2) / 50
a = position - dispersion * 670
x = np.arange(1340)
x = a + dispersion * x
#x = claser - 1e8 / x / n_air
return x
def deflections(self, xin, yin):
from numpy import ones, arctan as atan, arctanh as atanh
from math import cos, sin, pi
from numpy import arcsin as asin, arcsinh as asinh
x, y = self.align_coords(xin, yin)
q = self.q
if q == 1.:
q = 1. - 1e-7 # Avoid divide-by-zero errors
eps = (1. - q**2)**0.5
if self.eta == 1.:
# SIE models
r = (x**2 + y**2)**0.5
r[r == 0.] = 1e-9
xout = self.b * asinh(eps * x / q / r) * q**0.5 / eps
yout = self.b * asin(eps * y / r) * q**0.5 / eps
else:
from powerlaw import powerlawdeflections as pld
b, eta = self.b, self.eta
s = 1e-7
if x.ndim > 1:
yout, xout = pld(-1 * y.ravel(), x.ravel(), b, eta, s, q)
xout, yout = xout.reshape(x.shape), -1 * yout.reshape(y.shape)
else:
yout, xout = pld(-1 * y, x, b, eta, s, q)
yout = -1 * yout
theta = -(self.theta - pi / 2.)
ctheta = cos(theta)
stheta = sin(theta)
x = xout * ctheta + yout * stheta
y = yout * ctheta - xout * stheta
return x, y
def action_asin():
Showtemplabel.delete(0, END);
Showlabel.delete(0, END)
Showtemplabel.config(fg='yellow', bg='#8dad96')
Showtemplabel.insert(0, 'asin');
Showtemplabel.place(relx=0.5, rely=0.5, anchor='center')
ans = "0"
Showlabel.insert(0, ans);
Showlabel.place(relx=0.5, rely=0.6, anchor='center')
num1 = Numberentry1.get();
if(is_number(num1)==True):
num1 = casting(num1)
ans = str(np.asin(num1))
Showtemplabel.delete(0, END);
Showlabel.delete(0, END)
Showtemplabel.config(fg='yellow', bg='#8dad96')
Showtemplabel.insert(0, 'sin_-1');
Showtemplabel.place(relx=0.5, rely=0.5, anchor='center')
Showlabel.insert(0, ans);
Showlabel.place(relx=0.5, rely=0.6, anchor='center')
else:
messagebox.showerror("Error", "Enter a Valid number\ne.g. 123, 0.123, .123, -0.123, 123.456")
def ecef2aer(obs_lla, ecef_sat, ecef_obs):
"""
:Ref: Geometric Reference Systems in Geodesy by Christopher Jekeli, Ohio State University, August 2016
https://kb.osu.edu/bitstream/handle/1811/77986/Geom_Ref_Sys_Geodesy_2016.pdf?sequence=1&isAllowed=y
:param obs_lla: observations in lat, lon, height (deg, deg, m)
:param ecef_sat:
:return: array[azimuth, elevation, slant]
"""
lat, lon = obs_lla[0], obs_lla[1] # phi, lambda
trans_uvw_ecef = array(
[[-sin(lat) * cos(lon), -sin(lon),
cos(lat) * cos(lon)],
[-sin(lat) * sin(lon),
cos(lon), cos(lat) * sin(lon)], [cos(lat), 0,
sin(lat)]]) # (eq 2.153)
delta_ecef = ecef_sat - ecef_obs # (eq 2.149)
R_enz = trans_uvw_ecef.T @ delta_ecef # (eq 2.153)
r = sqrt(sum(delta_ecef**2)) # (eq 2.156)
az = atan2(R_enz[1], (R_enz[0])) # (eq 2.154)
if az < 0:
az = az + 2 * pi
el = asin(R_enz[2] / r) # (eq 2.155)
aer = array([az, el, r])
return aer
def __inverse_2D(self, x, y):
l1 = self.link_lengths[0]
l2 = self.link_lengths[1]
L = np.sqrt(x**2 + y**2)
psi = np.asin(x / L)
phi = np.acos((l1**2 + l2**2 - L**2) / (2 * l1 * l))
return [th1, th2]
def euclidian_dist_to_angular_dist(dist, r=1):
"""
The inverse of angular_dist_to_euclidian_dist.
Parameters
----------
dist: array-like or scalar
Euclidian distance in the same units as r
r: scalar (optional)
The radius of the sphere that you're projecting onto. Default
is 1.
Returns
-------
angular_separation: numpy array or scalar (matches input)
Angular separation in degrees that corresponds to the Euclidean
distance(s)
"""
#If it's an array, make sure that it's a numpy array so that nothing
#weird happens in the vector operations
try:
n_dists = len(dist)
except TypeError:
n_dists = 1
else:
dist = np.array(dist)
#Return the distance
return 180./np.pi * 2. * np.asin(dist/(2.*r))
def quaternion_to_euler(quat):
# https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles
# Needs to be checked for correctness given openGL coordinate system
q0, q1, q2, q3 = quat
phi = np.atan2(2*(q0*q1 + q2*q3), 1-2*(q1**2 + q2**2))
theta = np.asin(2*(q0*q2 - q3*q1))
psi = np.atan2(2*(q0*q3 + q1*q2), 1 - 2*(q2**2 + q3**2))
return phi, theta, psi
def radec2azel(ra_deg: float,
dec_deg: float,
lat_deg: float,
lon_deg: float,
time: datetime,
usevallado: bool = True) -> Tuple[float, float]:
"""
converts right ascension, declination to azimuth, elevation
Parameters
----------
ra_deg : float
right ascension to target [degrees]
dec_deg : float
declination to target [degrees]
lat_deg : float
observer WGS84 latitude [degrees]
lon_deg : float
observer WGS84 longitude [degrees]
time : datetime.datetime
time of observation
Results
-------
az_deg : float
azimuth clockwise from north to point [degrees]
el_deg : float
elevation above horizon to point [degrees]
from D. Vallado "Fundamentals of Astrodynamics and Applications "
4th Edition Ch. 4.4 pg. 266-268
"""
if abs(lat_deg) > 90:
raise ValueError("-90 <= lat <= 90")
ra = radians(ra_deg)
dec = radians(dec_deg)
lat = radians(lat_deg)
lon = radians(lon_deg)
lst = datetime2sidereal(time, lon) # RADIANS
# %% Eq. 4-11 p. 267 LOCAL HOUR ANGLE
lha = lst - ra
# %% #Eq. 4-12 p. 267
el = asin(sin(lat) * sin(dec) + cos(lat) * cos(dec) * cos(lha))
# %% combine Eq. 4-13 and 4-14 p. 268
az = atan2(-sin(lha) * cos(dec) / cos(el),
(sin(dec) - sin(el) * sin(lat)) / (cos(el) * cos(lat)))
return degrees(az) % 360.0, degrees(el)
def QL2T(Q=None,L=None):
"""
Compute angle from Q and wavelength.
T = asin( |Q| L / 4 pi )
Returns T in degrees.
"""
return degrees(asin(abs(Q) * L / (4*pi)))
def QL2T(Q=None, L=None):
"""
Compute angle from Q and wavelength.
T = asin( |Q| L / 4 pi )
Returns T in degrees.
"""
return degrees(asin(abs(Q) * L / (4 * pi)))
def PW91k_paramke(s, k):
A = k[0] @ s * np.asin(k[4] * s)
B = (k[1] - k[2] @ np.exp(-k[3] @ s**2)) * s**2
C = k[5] @ s**4
F = (1 + A + B) / (1 + A + C)
return F
def cart_2_flight_elements(cart):
""" Return flight elements from cartesian coordinates.
Parameters
----------
cart: float array
Cartesian coordinates
Returns
-------
flight_elem: float array
Flight elements
"""
flight_elem = np.zeros(6)
#position and velocity magnitude
r = np.sqrt(cart[0]**2+cart[1]**2+cart[2]**2)
v = np.sqrt(cart[3]**2+cart[4]**2+cart[5]**2)
#right ascension (alpha)
alpha = np.acos(cart[0]/np.sqrt(cart[0]**2+cart[1]**2))
#declination (delta)
delta = np.asin(cart[2]/r)
#matrice to transform a vector in the SEZ system
m = np.zeros(3,3)
m[0,0] = np.cos(alpha)*np.cos(delta)
m[0,1] = np.sin(alpha)*np.cos(delta)
m[0,2] = -np.sin(delta)
m[1,0] = -np.sin(alpha)
m[1,1] = np.cos(alpha)
m[1,2] = 0.0
m[1,0] = np.sin(delta)*np.cos(alpha)
m[1,1] = np.sin(alpha)*np.sin(delta)
m[1,2] = np.cos(delta)
v_sez = m*cart[3:5]
#flight-path angle from the local horizontal
phi = np.acos(v_sez[2]/v)
#azimut (beta)
beta = np.acos(-v_sez[0]/np.sqrt(v_sez[0]**2+v_sez[1]**2))
flight_elem[0] = r
flight_elem[1] = v
flight_elem[2] = alpha
flight_elem[3] = delta
flight_elem[4] = phi
flight_elem[5] = beta
return flight_elem
def azel2radec(az_deg: float,
el_deg: float,
lat_deg: float,
lon_deg: float,
time: datetime,
usevallado: bool = True) -> Tuple[float, float]:
"""
converts azimuth, elevation to right ascension, declination
Parameters
----------
az_deg : float
azimuth (clockwise) to point [degrees]
el_deg : float
elevation above horizon to point [degrees]
lat_deg : float
observer WGS84 latitude [degrees]
lon_deg : float
observer WGS84 longitude [degrees]
time : datetime.datetime
time of observation
Results
-------
ra_deg : float
right ascension to target [degrees]
dec_deg : float
declination of target [degrees]
from D.Vallado Fundamentals of Astrodynamics and Applications
p.258-259
"""
if abs(lat_deg) > 90:
raise ValueError("-90 <= lat <= 90")
az = radians(az_deg)
el = radians(el_deg)
lat = radians(lat_deg)
lon = radians(lon_deg)
# %% Vallado "algorithm 28" p 268
dec = asin(sin(el) * sin(lat) + cos(el) * cos(lat) * cos(az))
lha = atan2(-(sin(az) * cos(el)) / cos(dec),
(sin(el) - sin(lat) * sin(dec)) / (cos(dec) * cos(lat)))
lst = datetime2sidereal(time, lon) # lon, ra in RADIANS
""" by definition right ascension [0, 360) degrees """
return degrees(lst - lha) % 360, degrees(dec)
def ang_rel2abs_2(self, ang):
my_ang = ang
output = 0
while my_ang > self.ang_const:
output += np.pi
my_ang -= 2 * self.ang_const
while my_ang < -self.ang_const:
output -= np.pi
my_ang += 2 * self.ang_const
return output + np.asin(my_ang / self.ang_const)
def HaversineFormula(lat1,lon1,lat2,lon2):
lat1 = lat1*pi/180.0
lon1 = lon1*pi/180.0
lat2 = lat2*pi/180.0
lon2 = lon2*pi/180.0
dlat = lat2-lat1
dlon = lon2-lon1
h = hav(dlat) + cos(lat1)*cos(lat2)*hav(dlon)
d = 2*R*asin(h**0.5)
return d
def asin(*args, **kw):
arg0 = args[0]
if isinstance(arg0, (int, float, long)):
return _math.asin(*args,**kw)
elif isinstance(arg0, complex):
return _cmath.asin(*args,**kw)
elif isinstance(arg0, _sympy.Basic):
return _sympy.asin(*args,**kw)
else:
return _numpy.asin(*args,**kw)
def QL2T(Q=None,L=None):
r"""
Compute angle from $Q$ (|1/Ang|) and wavelength (|Ang|).
.. math::
\theta = \sin^{-1}( |Q| \lambda / 4 \pi )
Returns $\theta$\ |deg|.
"""
Q,L = asarray(Q,'d'), asarray(L,'d')
return degrees(asin(abs(Q) * L / (4*pi)))
def quaternion_to_euler(x, y, z, w):
t0 = +2.0 * (w * x + y * z)
t1 = +1.0 - 2.0 * (x * x + y * y)
roll = np.atan2(t0, t1)
t2 = +2.0 * (w * y - z * x)
t2 = +1.0 if t2 > +1.0 else t2
t2 = -1.0 if t2 < -1.0 else t2
pitch = np.asin(t2)
t3 = +2.0 * (w * z + x * y)
t4 = +1.0 - 2.0 * (y * y + z * z)
yaw = np.atan2(t3, t4)
return yaw, pitch, roll
def solar_declination(ls=None):
"""Returns the solar declination"""
if ls is None:
ls= Mars_Ls()
ls1 = ls * np.pi/180.
if use_numpy:
dec = np.arcsin(0.42565 * np.sin(ls1)) + 0.25*(np.pi/180) * np.sin(ls1)
else:
dec = np.asin(0.42565 * np.sin(ls1)) + 0.25*(np.pi/180) * np.sin(ls1)
dec = dec * 180. / np.pi
return dec
def QL2T(Q=None, L=None):
r"""
Compute angle from $Q$ (|1/Ang|) and wavelength (|Ang|).
.. math::
\theta = \sin^{-1}( |Q| \lambda / 4 \pi )
Returns $\theta$\ |deg|.
"""
Q, L = asarray(Q, 'd'), asarray(L, 'd')
return degrees(asin(abs(Q) * L / (4*pi)))
def DCM2Euler321(C):
"""
C2Euler321
Q = C2Euler321(C) translates the 3x3 direction cosine matrix
C into the corresponding (3-2-1) Euler angle set.
"""
q = np.zeros(3)
q[0] = np.atan2(C[0, 1], C[0, 0])
q[1] = np.asin(-C[0, 2])
q[2] = np.atan2(C[1, 2], C[2, 2])
return q
def deflections(self, xin, yin, d=1):
b = self.b * d
from numpy import ones, arctan as atan, arctanh as atanh
from math import cos, sin, pi
from numpy import arcsin as asin, arcsinh as asinh
x, y = self.align_coords(xin, yin, False)
q = self.q
if q == 1.:
q = 1. - 1e-7 # Avoid divide-by-zero errors
eps = (1. - q**2)**0.5
if self.eta == 1.:
# SIE models
r = (x**2 + y**2)**0.5
r[r == 0.] = 1e-9
# xout = self.b*asinh(eps*x/q/r)*q**0.5/eps
# yout = self.b*asin(eps*y/r)*q**0.5/eps
xout = b * asinh(eps * y / q / r) * q**0.5 / eps
yout = b * asin(eps * -x / r) * q**0.5 / eps
xout, yout = -yout, xout
x, y = self.align_coords(xout, yout, False, revert=True)
return x - self.x, y - self.y
theta = 2 - self.theta #-(self.theta - pi/2.)
ctheta = cos(theta)
stheta = sin(theta)
x = xout * ctheta + yout * stheta
y = yout * ctheta - xout * stheta
return x, y
else:
from powerlaw import powerlawdeflections as pld
b, eta = b, self.eta
s = 1e-4
if x.ndim > 1:
# yout,xout = pld(-1*y.ravel(),x.ravel(),b,eta,s,q)
# xout,yout = xout.reshape(x.shape),-1*yout.reshape(y.shape)
xout, yout = pld(x.ravel(), y.ravel(), b, eta, s, q)
xout, yout = xout.reshape(x.shape), yout.reshape(y.shape)
else:
xout, yout = pld(x, y, b, eta, s, q)
# yout,xout = pld(-1*y,x,b,eta,s,q)
# yout = -1*yout
# theta = -(self.theta - pi/2.)
# ctheta = cos(theta)
# stheta = sin(theta)
# x = xout*ctheta+yout*stheta
# y = yout*ctheta-xout*stheta
# return x,y
x, y = self.align_coords(xout, yout, False, revert=True)
return x - self.x, y - self.y
def moon_rst_altitude(r):
""" Returnn the standard altitude of the Moon.
Arguments:
- `r` : Distance between the centers of the Earth and Moon, in km.
Returns:
- Standard altitude in radians.
"""
# horizontal parallax
parallax = np.asin(earth_equ_radius / r)
return 0.7275 * parallax + standard_rst_altitude
def solar_declination(ls=None):
"""Returns the solar declination"""
if ls is None:
ls = Mars_Ls()
ls1 = ls * np.pi / 180.
if use_numpy:
dec = np.arcsin(
0.42565 * np.sin(ls1)) + 0.25 * (np.pi / 180) * np.sin(ls1)
else:
dec = np.asin(
0.42565 * np.sin(ls1)) + 0.25 * (np.pi / 180) * np.sin(ls1)
dec = dec * 180. / np.pi
return dec
def evaluate(self, xOrig):
"""
Calculates and returns RV curve according to current model parameters.
.. note:: The units of the model RV curve are **stellar-radii per second**.
Parameters
----------
xOrig : array
The time stamps at which to calculate the model RV curve.
Note that the orbit period and central transit time are used
to convert time into "true anomaly".
"""
x = self.trueAnomaly(xOrig)
Xp = self.Xp(x)
Zp = self.Zp(x)
rho = self.rho(Xp, Zp)
etap = self.etap(Xp, Zp)
zeta = self.zeta(etap)
x0 = self.x0(etap)
xc = self.xc(zeta, x0)
# dphase is the phase difference between the primary transit and the time points
# It is used to exclude the secondary transit from the calculations
dphase = np.abs((xOrig - self["T0"]) / self["P"])
dphase = np.minimum(dphase - np.floor(dphase),
np.abs(dphase - np.floor(dphase) - 1))
y = np.zeros(len(x))
indi = np.where(
np.logical_and(rho < (1.0 - self["gamma"]), dphase < 0.25))[0]
y[indi] = Xp[indi] * self["Omega"] * sin(self["Is"]) * self["gamma"]**2 * \
(1.0 - self["epsilon"] * (1.0 - self.W2(rho[indi]))) / \
(1.0 - self["gamma"]**2 - self["epsilon"] * (1. /
3. - self["gamma"]**2 * (1.0 - self.W1(rho[indi]))))
indi = np.where(
np.logical_and(
np.logical_and(rho >= 1. - self["gamma"],
rho < 1.0 + self["gamma"]), dphase < 0.25))[0]
z0 = self.z0(etap, indi)
y[indi] = (Xp[indi] * self["Omega"] * sin(self["Is"]) * (
(1.0 - self["epsilon"]) * (-z0[indi] * zeta[indi] + self["gamma"]**2 * acos(zeta[indi] / self["gamma"])) +
(self["epsilon"] / (1.0 + etap[indi])) * self.W4(x0[indi], zeta[indi], xc[indi], etap[indi]))) / \
(pi * (1. - 1.0 / 3.0 * self["epsilon"]) - (1.0 - self["epsilon"]) * (asin(z0[indi]) - (1. + etap[indi]) * z0[indi] +
self["gamma"]**2 * acos(zeta[indi] / self["gamma"])) - self["epsilon"] * self.W3(x0[indi], zeta[indi], xc[indi], etap[indi]))
return y
def fitsh_projection_do_inverse_matrix_coord(mproj, x, y):
z = 1.0 - x**2 - y**2
z = -np.sqrt(z)
px = mproj[0, 0] * x + mproj[1, 0] * y + mproj[2, 0] * z
py = mproj[0, 1] * x + mproj[1, 1] * y + mproj[2, 1] * z
pz = mproj[0, 2] * x + mproj[1, 2] * y + mproj[2, 2] * z
rde = np.asin(pz) * 180.0 / np.pi
rra = np.atan2(py, px) * 180.0 / np.pi
if rra < 0.0:
rra = rra + 360.0
return [rra, rdec]
def evaluate(self, xOrig):
"""
Calculates and returns RV curve according to current model parameters.
.. note:: The units of the model RV curve are **stellar-radii per second**.
Parameters
----------
xOrig : array
The time stamps at which to calculate the model RV curve.
Note that the orbit period and central transit time are used
to convert time into "true anomaly".
"""
self._setkepellpars()
# In coordinate system with observer in -z axis
pos = self._ke.xyzPos(xOrig)
# Use coordinate used by Ohta (looking into -y direction)
Xp = -pos[::, 0]
Zp = pos[::, 1]
Yp = pos[::, 2]
rho = RmcL.rho(self, Xp, Zp)
etap = RmcL.etap(self, Xp, Zp)
zeta = RmcL.zeta(self, etap)
x0 = RmcL.x0(self, etap)
xc = RmcL.xc(self, zeta, x0)
# Planet in front of star
y = np.zeros_like(xOrig)
indi = np.where((Yp < 0) & (rho < (1.0 - self["gamma"])))[0]
y[indi] = Xp[indi] * self["Omega"] * sin(self["Is"]) * self["gamma"]**2 * \
(1.0 - self["epsilon"] * (1.0 - RmcL.W2(self, rho[indi]))) / \
(1.0 - self["gamma"]**2 - self["epsilon"] * (1. /
3. - self["gamma"]**2 * (1.0 - RmcL.W1(self, rho[indi]))))
indi = np.where((rho >= 1. - self["gamma"])
& (rho < 1.0 + self["gamma"]) & (Yp < 0))[0]
z0 = RmcL.z0(self, etap, indi)
y[indi] = (Xp[indi] * self["Omega"] * sin(self["Is"]) * (
(1.0 - self["epsilon"]) * (-z0[indi] * zeta[indi] + self["gamma"]**2 * acos(zeta[indi] / self["gamma"])) +
(self["epsilon"] / (1.0 + etap[indi])) * RmcL.W4(self, x0[indi], zeta[indi], xc[indi], etap[indi]))) / \
(pi * (1. - 1.0 / 3.0 * self["epsilon"]) - (1.0 - self["epsilon"]) * (asin(z0[indi]) - (1. + etap[indi]) * z0[indi] +
self["gamma"]**2 * acos(zeta[indi] / self["gamma"])) - \
self["epsilon"] * RmcL.W3(self, x0[indi], zeta[indi], xc[indi], etap[indi]))
return y
def randLonLat( n=1, lon1=-180.0, lon2=180.0, lat1=-90.0, lat2=90.0 ):
"""
Get n random lon/lat points in degrees
"""
# deg/radian conversion
D2R=pi/180.0
R2D=1/D2R
# get lons
lons = lon1 + (lon2-lon1)*NPR.rand( n, 1 )
# correct for area and get rand lat
z1, z2 = sin( D2R*lat1 ) , sin( R2D*lat2 )
lats = R2D*asin( z1 + (z2-z1)*NPR.rand( n,1 ) )
return (lons, lats)
def uvw2aer(uvw):
"""
:param uvw:
:return: array[azimuth, elevation, slant]
"""
# Ref: Geometric Reference Systems in Geodesy by Christopher Jekeli, Ohio State University, August 2016
# https://kb.osu.edu/bitstream/handle/1811/77986/Geom_Ref_Sys_Geodesy_2016.pdf?sequence=1&isAllowed=y
# 2.2.2 Local Terrestrial Coordinates defined u, v, w
u, v, w = uvw
r = sqrt(sum(uvw**2)) # (eq 2.156)
az = atan2(v, u) # (eq 2.154)
if az < 0:
az = az + tau
el = asin(w / r) # (eq 2.155)
aer = array([az, el, r])
return aer
def randLonLat(n=1, lon1=-180.0, lon2=180.0, lat1=-90.0, lat2=90.0):
"""
Get n random lon/lat points in degrees
"""
# deg/radian conversion
D2R = pi / 180.0
R2D = 1 / D2R
# get lons
lons = lon1 + (lon2 - lon1) * NPR.rand(n, 1)
# correct for area and get rand lat
z1, z2 = sin(D2R * lat1), sin(R2D * lat2)
lats = R2D * asin(z1 + (z2 - z1) * NPR.rand(n, 1))
return (lons, lats)
def azel_from_ecef(pos, ref):
"""Returns the azimuth and elevation between two ECEF points"""
# Calculate the vector from the reference point in the local North, East,
# Down frame of the reference point. */
ned = ned_from_ecef(pos - ref, pos, ref)
az = np.atan2(ned[1], ned[0])
# atan2 returns angle in range [-pi, pi], usually azimuth is defined in the
# range [0, 2pi]. */
if (az < 0):
az += 2 * np.pi
el = np.asin(-ned[2] / np.linalg.norm(ned))
return az, el
def oop_calc(i,j,k,l):
label = atomLabel[i] + str(i+1) + "-" + atomLabel[j] + str(j+1) + "-" + atomLabel[k] + str(k+1) + "-" + atomLabel[l] + str(l+1)
v_kl = np.array([float(xCoord[k]) - float(xCoord[l]),float(yCoord[k]) - float(yCoord[l]),float(zCoord[k]) - float(zCoord[l])])
v_ki = np.array([float(xCoord[k]) - float(xCoord[i]),float(yCoord[k]) - float(yCoord[i]),float(zCoord[k]) - float(zCoord[i])])
v_kj = np.array([float(xCoord[k]) - float(xCoord[j]),float(yCoord[k]) - float(yCoord[j]),float(zCoord[k]) - float(zCoord[j])])
e_kl = np.divide(v_kl,np.linalg.norm(v_kl))
e_ki = np.divide(v_ki,np.linalg.norm(v_ki))
e_kj = np.divide(v_kj,np.linalg.norm(v_kj))
theta_jkl = np.arccos(np.dot(e_kj,e_kl))
a = np.dot(np.cross(e_kj,e_kl),e_ki)
b = np.sin(theta_jkl)
sin_theta = a/b
theta = (180.0/np.pi)*np.asin(round(sin_theta,5))
oop.append(theta)
oopLabel.append(label)
return(oopLabel,oop)
def haversine(lon1, lat1, lon2, lat2, earth_radius):
"""
Great circle distance between two points using Haversine formula
modified from Michael Dunn's answer on Stack Overflow:
http://stackoverflow.com/questions/4913349/haversine-formula-in-python-bearing-and-distance-between-two-gps-points
Answer specified in decimal degrees.
"""
# convert decimal degrees to radians
lon1, lat1, lon2, lat2 = map(np.radians, [lon1, lat1, lon2, lat2])
# haversine formula
delt_lon = lon2 - lon1
delt_lat = lat2 - lat1
a = np.sin(delt_lat/2)**2 + np.cos(lat1) * np.cos(lat2) * np.sin(delt_lon/2)**2
c = 2 * earth_radius * np.asin(np.sqrt(a))
return c
def evaluate(self, xOrig):
"""
Calculates and returns RV curve according to current model parameters.
.. note:: The units of the model RV curve are **stellar-radii per second**.
Parameters
----------
xOrig : array
The time stamps at which to calculate the model RV curve.
Note that the orbit period and central transit time are used
to convert time into "true anomaly".
"""
x = self.trueAnomaly(xOrig)
Xp = self.Xp(x)
Zp = self.Zp(x)
rho = self.rho(Xp, Zp)
etap = self.etap(Xp, Zp)
zeta = self.zeta(etap)
x0 = self.x0(etap)
xc = self.xc(zeta, x0)
# dphase is the phase difference between the primary transit and the time points
# It is used to exclude the secondary transit from the calculations
dphase = numpy.abs((xOrig-self["T0"])/self["P"])
dphase = numpy.minimum( dphase-numpy.floor(dphase), numpy.abs(dphase-numpy.floor(dphase)-1))
y = numpy.zeros(len(x))
indi = numpy.where(numpy.logical_and(rho < (1.0-self["gamma"]), dphase < 0.25))[0]
y[indi] = Xp[indi]*self["Omega"]*sin(self["Is"])* self["gamma"]**2 * \
(1.0 - self["epsilon"]*(1.0 - self.W2(rho[indi]))) / \
(1.0 - self["gamma"]**2 - self["epsilon"]*(1./3. - self["gamma"]**2*(1.0-self.W1(rho[indi]))))
indi = numpy.where(numpy.logical_and( \
numpy.logical_and(rho >= 1.-self["gamma"], rho < 1.0+self["gamma"]), dphase < 0.25))[0]
z0 = self.z0(etap, indi)
y[indi] = (Xp[indi]*self["Omega"]*sin(self["Is"])*( \
(1.0-self["epsilon"]) * (-z0[indi]*zeta[indi] + self["gamma"]**2*acos(zeta[indi]/self["gamma"])) + \
(self["epsilon"]/(1.0+etap[indi]))*self.W4(x0[indi], zeta[indi], xc[indi], etap[indi]))) / \
(pi*(1.-1.0/3.0*self["epsilon"]) - (1.0-self["epsilon"]) * (asin(z0[indi])-(1.+etap[indi])*z0[indi] + \
self["gamma"]**2*acos(zeta[indi]/self["gamma"])) - self["epsilon"]*self.W3(x0[indi], zeta[indi], xc[indi], etap[indi]))
return y
def trace(self, photon, normal, free_pathlength):
"""Move the photon one Monte-Carlo step forward by considering material reflections."""
# Absorption is not defined for this material (we assume dielectrics)
# Therefore is random number is less than reflectivty: photon reflected.
if isinstance(self.reflectivity, Spectrum):
R = self.reflectivity.value(photon.wavelength)
if isinstance(self.reflectivity, AngularSpectrum):
# DJF 8/5/2010
#
# The internal incident angle (substate-coating) will not correspond to the same value of
# reflectivity as for the same angle and the external interface (air-coatings) because the
# refraction angle into the material will be different. We need to apply a correction factor
# to account for this effect (see Farrell PhD Thesis, p.129, 2009)
#
# If the previous containing object's (i.e. this will be the substate for an internal
# collision, or air if an external collision) has a refractive index higher than air
# (n_air = photon.scene.bounds.material.refractive_index) then the correction is applied,
# else the photon must be heading into an external interface and no correction is needed.
#
if photon.previous_container.material.refractive_index > photon.scene.bounds.material.refractive_index:
# Hitting internal interface, therefore apply correction to angle
n_substrate = photon.previous_container.material.refractive_index
n_environment = photon.scene.bounds.material.refractive_index
rads = np.asin(n_substrate/n_environment * sin( angle(normal, photon.direction) ))
else:
rads = angle(normal, photon.direction)
R = self.reflectivity.value(photon.wavelength, rads)
else:
R = self.reflectivity
rn = np.random.uniform()
if rn < R:
# Reflected
photon.direction = reflect_vector(normal, photon.direction)
else:
photon.position = photon.position + free_pathlength * photon.direction
return photon
def quat2euler(r, i, j, k):
"""
Converts a quaternion to Euler angles
@type r: float
@param r: Real part of quaternion
@type i: float
@param i: Imaginary i part of quaternion
@type j: float
@param j: Imaginary j part of quaternion
@type k: float
@param k: Imaginary k part of quaternion
@rtype: tuple
@return: (phi, theta, psi) Euler angles
phi - (float) Roll angle in radians
theta - (float) Pitch angle in radians
psi - (float) Yaw angle in radians
"""
r = float(r)
i = float(i)
j = float(j)
k = float(k)
if not np.isclose(np.array(np.sqrt(r*r+i*i+j*j+k*k)), 1.0):
raise Exception("Invalid argument:\n" + \
str(r) + " " + str(i) + " " + str(j) + " " + str(k) + \
"\n" + "Valid types: norm of [r i j k] = 1")
phi = atan2(2*(r*i + j*k), 1 - 2*(i**2 + j**2))
theta = asin(2*(r*j - k*i))
psi = atan2(2*(r*k + i*j), 1 - 2*(j**2 + k**2))
return (phi, theta, psi)
def caustic(self):
if self.eta != 1:
return None, None
from numpy import ones, arctan as atan, arctanh as atanh
from numpy import cos, sin, pi, linspace
from numpy import arcsin as asin, arcsinh as asinh
q = self.q
if q == 1.:
q = 1. - 1e-7 # Avoid divide-by-zero errors
eps = (1. - q**2)**0.5
theta = linspace(0, 2 * pi, 5000)
ctheta = cos(theta)
stheta = sin(theta)
delta = (ctheta**2 + q**2 * stheta**2)**0.5
xout = ctheta * q**0.5 / delta - asinh(eps * ctheta / q) * q**0.5 / eps
yout = stheta * q**0.5 / delta - asin(eps * stheta) * q**0.5 / eps
xout, yout = xout * self.b, yout * self.b
theta = -(self.theta - pi / 2.)
ctheta = cos(theta)
stheta = sin(theta)
x = xout * ctheta + yout * stheta
y = yout * ctheta - xout * stheta
return x + self.x, y + self.y
def dist2GC(cLon1, cLat1, cLon2, cLat2, lonArray, latArray, units="km"):
"""
Calculate the distance between an array of points and the great circle
joining two (other) points.
All input values are in degrees.
By default returns distance in km, other units specified by the
'units' kwarg.
Based on a cross-track error formulation from:
http://williams.best.vwh.net/avform.htm#XTE
"""
# Calculate distance and bearing from first point to array of points:
dist_ = gridLatLonDist(cLon1, cLat1, lonArray, latArray, units="rad")
bear_ = gridLatLonBear(cLon1, cLat1, lonArray, latArray)
#bearing of the cyclone:
cyc_bear_ = latLon2Azi([cLon1, cLon2], [cLat1, cLat2])
dist2GC_ = np.asin(np.sin(dist_) * np.sin(bear_ - cyc_bear_))
distance = metutils.convert(dist2GC_, "rad", units)
return distance
def Rswd(DEM, Lat, Trans, DOY, Time):
""" Potential Radiation Equator model
(c) O. van Dam, UU, Tropenbos-Guyana
Version 5, June 2000
NOTE: Copyright: This program is free to use provided·
you refer to the manualfor citation.
Do not distribute without prior approval of the author.
Manual and additional info: [email protected]
-----------------------------------------------------
Model for calculation
incoming potential light energy
-----------------------------------------------------
DEM Input Digital Elevation Model (spatial)
Lat Latitude in decimal degrees (non-spatia)
Trans Transmissivity tau (Gates, 1980) (non-spatial)
DOY Day of Year (non-spatial)
Time Time in hours (non-spatial)"""
# constants
pi = 3.1415 # pi
Sc = 1367.0 # Solar constant (Gates, 1980) [W/m2]
SlopMap = scalar(atan(slope(DEM)))
AspMap = scalar(aspect(DEM)) # aspect [deg]
AtmPcor = ((288.0-0.0065*DEM)/288.0)**5.256 # atmospheric pressure correction [-]
# Solar geometry
# ----------------------------
# SolDec :declination sun per day between +23 & -23 [deg]
# HourAng :hour angle [-] of sun during day
# SolAlt :solar altitude [deg], height of sun above horizon
SolDec = -23.4*cos(360.0*(DOY+10.0)/365.0)
HourAng = 15.0*(Time-12.01)
SolAlt = scalar(asin(scalar(sin(Lat)*sin(SolDec)+cos(Lat)*cos(SolDec)*cos(HourAng))))
# Solar azimuth
# ----------------------------
# SolAzi :angle solar beams to N-S axes earth [deg]
SolAzi = scalar(acos((sin(SolDec)*cos(Lat)-cos(SolDec)*sin(Lat)*cos(HourAng))/cos(SolAlt)))
SolAzi = ifthenelse(Time <= 12.0, SolAzi, 360.0 - SolAzi)
# Additonal extra correction by R.Sluiter, Aug '99
#SolAzi = ifthenelse(SolAzi > 89.994 and SolAzi < 90.0, 90.0, SolAzi)
#SolAzi = ifthenelse(SolAzi > 269.994 and SolAzi < 270.0, 270.0, SolAzi)
SolAzi = ifthenelse(np.logical_and(SolAzi > 89.994, SolAzi < 90.0), 90.0, SolAzi)
SolAzi = ifthenelse(np.logical_and(SolAzi > 269.994, SolAzi < 270.0), 270.0, SolAzi)
# Surface azimuth
# ----------------------------
# cosIncident :cosine of angle of incident; angle solar beams to angle surface
cosIncident = sin(SolAlt)*cos(SlopMap)+cos(SolAlt)*sin(SlopMap)*cos(SolAzi-AspMap)
# Critical angle sun
# ----------------------------
# HoriAng :tan maximum angle over DEM in direction sun, 0 if neg·
# CritSun :tan of maximum angle in direction solar beams
# Shade :cell in sun 1, in shade 0
#HoriAng = horizontan(DEM,directional(SolAzi))
HoriAng = scalar(0.3)
HoriAng = ifthenelse(HoriAng < 0.0, scalar(0.0), HoriAng)
CritSun = ifthenelse(SolAlt > 90.0, scalar(0.0), scalar(atan(HoriAng)))
Shade = ifthenelse(SolAlt > CritSun, scalar(1), scalar(0))
# Radiation outer atmosphere
# ----------------------------
OpCorr = Trans**((sqrt(1229.0+(614.0*sin(SolAlt))**2.0)-614.0*sin(SolAlt))*AtmPcor) # correction for air masses [-]·
Sout = Sc*(1.0+0.034*cos(360.0*DOY/365.0)) # radiation outer atmosphere [W/m2]
Snor = Sout*OpCorr # rad on surface normal to the beam [W/m2]
# Radiation at DEM
# ----------------------------
# Sdir :direct sunlight on a horizontal surface [W/m2] if no shade
# Sdiff :diffuse light [W/m2] for shade and no shade
# Stot :total incomming light Sdir+Sdiff [W/m2] at Hour
# PotRad :avg of Stot(Hour) and Stot(Hour-HourStep)
Sdir = ifthenelse(Snor*cosIncident*Shade < 0.0, 0.0, Snor*cosIncident*Shade)
Sdiff = ifthenelse(Sout*(0.271-0.294*OpCorr)*sin(SolAlt) < 0.0, 0.0, Sout*(0.271-0.294*OpCorr)*sin(SolAlt))
#Rswd = Sdir + Sdiff # Rad [W/m2]
Rswd = Snor
return Rswd
'Clarke 1866' : 6378206.4,
'Bessel 1841' : 6377397.155,
'International 1924' : 6378388,
'Krasovsky 1940' : 6378245,
'GRS80' : 6378137,
'WGS84' : 6378137,
}.get(elip, 6371000)
rlat = omapy
rlon = omapx
#R = select_earth_radius(ellipsoid)
sr = osr.SpatialReference()
sr.ImportFromWkt(img_prj)
R = sr.GetSemiMajor()
# to determine if projected
sr.IsProjected() # return 1 if True
# to determine if geographic
sr.IsGeographic() # return 1 if True
d = shadow_length
rlat2 = numpy.asin( numpy.sin(rlat)*numpy.cos(d/R) + numpy.cos(rlat)*numpy.sin(d/R)*numpy.cos(to_azi) )
rlon2 = rlon + numpy.atan2(numpy.sin(to_azi)*numpy.sin(d/R)*numpy.cos(rlat),numpy.cos(d/R)-numpy.sin(rlat)*numpy.sin(rlat))
rlat2 = numpy.deg2rad(rlat2)
rlon2 = numpy.deg2rad(rlon2)
returns [Lat2,Lon2]
"""
lat1=((lat1deg)/180*pi)
lon1=((lon1deg)/180*pi)
#thetadeg is bearing in degrees, convet to radians
theta=(thetadeg)/180*pi
#print theta
# Radius of the earth a=equatorial radius, b=polar radius
a=6378.137e3;
b=6356.7523e3;
phi=lat1
R=sqrt( ( pow(pow(a,2)*cos(phi),2) + pow(pow(b,2)*sin(phi),2) )/( pow(a*cos(phi),2) + pow(b*sin(phi),2) ))
#R=6371e3
lat2 = (asin(sin(lat1)*cos(d/R) + cos(lat1)*sin(d/R)*cos(theta)) )
#print lat2
lat2deg = lat2/pi*180
lon2 = (lon1 + atan2(sin(theta)*sin(d/R)*cos(lat1), cos(d/R)-sin(lat1)*sin(lat2)) )
#print lon2
#lon2 = (lon1 + atan2( cos(d/R)-sin(lat1)*sin(lat2), sin(theta)*sin(d/R)*cos(lat1) ))
lon2deg = lon2/pi*180
return([lat2deg, lon2deg])
#%52deg58'52?N, 000deg53'15?E
#Generates one point for a circle?\
def genCirclePoint(centreLat, centreLon, circleAngle, circleRadius, circleAlt):
"""
Gen coordinates for a circle point
expect decimal lat longs
returns one point as string?
def tilde_w(w, dt):
return (2./dt)*asin(w*dt/2.)
def g(self, x, e, g, x0):
result = (1.0-x**2) * asin(sqrt((g**2-(x-1.0-e)**2)/(1.0-x**2))) + \
sqrt(2.0*(1.0+e)*(x0-x)*(g**2-(x-1.0-e)**2))
return result
def __init__(self, h, T=None, L=None, thetao=None, Ho=None, lat=None):
self.T = np.asarray(T, dtype=np.float)
self.L = np.asarray(L, dtype=np.float)
self.Ho = np.asarray(Ho, dtype=np.float)
self.lat = np.asarray(lat, dtype=np.float)
self.thetao = np.asarray(thetao, dtype=np.float)
if isinstance(h, str):
if L is not None:
if h == 'deep':
self.h = self.L / 2.
elif h == 'shallow':
self.h = self.L * 0.05
else:
self.h = np.asarray(h, dtype=np.float)
if lat is None:
g = 9.81 # Default gravity.
else:
g = gsw.grav(lat, p=0)
if L is None:
self.omega = 2 * np.pi / self.T
self.Lo = (g * self.T ** 2) / 2 / np.pi
# Returns wavenumber of the gravity wave dispersion relation using
# newtons method. The initial guess is shallow water wavenumber.
self.k = self.omega / np.sqrt(g)
# TODO: May change to,
# self.k = self.w ** 2 / (g * np.sqrt(self.w ** 2 * self.h / g))
f = g * self.k * np.tanh(self.k * self.h) - self.omega ** 2
while np.abs(f.max()) > 1e-10:
dfdk = (g * self.k * self.h * (1 / (np.cosh(self.k * self.h)))
** 2 + g * np.tanh(self.k * self.h))
self.k = self.k - f / dfdk
# FIXME:
f = g * self.k * np.tanh(self.k * self.h) - self.omega ** 2
self.L = 2 * np.pi / self.k
if isinstance(h, str):
if h == 'deep':
self.h = self.L / 2.
elif h == 'shallow':
self.h = self.L * 0.05
else:
self.Lo = self.L / np.tanh(2 * np.pi * self.h / self.L)
self.k = 2 * np.pi / self.L
self.T = np.sqrt(2 * np.pi * self.Lo / g)
self.omega = 2 * np.pi / self.T
self.hoL = self.h / self.L
self.hoLo = self.h / self.Lo
self.C = self.omega / self.k # or L / T
self.Co = self.Lo / self.T
self.G = 2 * self.k * self.h / np.sinh(2 * self.k * self.h)
self.n = (1 + self.G) / 2
self.Cg = self.n * self.C
self.Ks = np.sqrt(1 / (1 + self.G) / np.tanh(self.k * self.h))
if thetao is None:
self.theta = np.NaN
self.Kr = np.NaN
if thetao is not None:
self.theta = np.rad2deg(np.asin(self.C / self.Co *
np.sin(np.deg2rad(self.thetao))))
self.Kr = np.sqrt(np.cos(np.deg2rad(self.thetao)) /
np.cos(np.deg2rad(self.theta)))
if Ho is None:
self.H = np.NaN
if Ho is not None:
self.H = self.Ho * self.Ks * self.Kr
