def eff(r):
if r * cosir > 1:
eff_r = r**2 * cosir - 1
else:
eff_r = (r**2 * cosir * 2 / np.pi *
asin(y(r))) - (2 / np.pi * asin(y(r) * r * cosir))
return eff_r
def cartesian_to_angular(x, y, z):
"""Converts from cartesian to angular coordinates
"""
norm = np.sqrt(x**2 + y**2 + z**2)
x = x / norm
y = y / norm
z = z / norm
dec = np.asin(z)
ra = np.atan2(y, x)
ra = ra * rad2deg
dec = dec * rad2deg
return numpy.array([ra, dec])
def test_against_uncertainties_package():
try:
from uncertainties import ufloat
from uncertainties import umath
from math import sqrt as math_sqrt
except ImportError:
return
X, varX = 0.5, 0.04
Y, varY = 3, 0.09
N = 3
ux = ufloat(X, math_sqrt(varX))
uy = ufloat(Y, math_sqrt(varY))
def _compare(result, u):
Z, varZ = result
assert abs(Z-u.n)/u.n < 1e-13 and (varZ-u.s**2)/u.s**2 < 1e-13, \
"expected (%g,%g) got (%g,%g)"%(u.n,u.s**2,Z,varZ)
def _check_pow(u):
_compare(pow(X, varX, N), u)
def _check_unary(op, u):
_compare(op(X, varX), u)
def _check_binary(op, u):
_compare(op(X, varX, Y, varY), u)
_check_pow(ux**N)
_check_binary(add, ux+uy)
_check_binary(sub, ux-uy)
_check_binary(mul, ux*uy)
_check_binary(div, ux/uy)
_check_binary(pow2, ux**uy)
_check_unary(exp, umath.exp(ux))
_check_unary(log, umath.log(ux))
_check_unary(sin, umath.sin(ux))
_check_unary(cos, umath.cos(ux))
_check_unary(tan, umath.tan(ux))
_check_unary(arcsin, umath.asin(ux))
_check_unary(arccos, umath.acos(ux))
_check_unary(arctan, umath.atan(ux))
_check_binary(arctan2, umath.atan2(ux, uy))
def test_against_uncertainties_package():
try:
from uncertainties import ufloat
from uncertainties import umath
from math import sqrt as math_sqrt
except ImportError:
return
X, varX = 0.5, 0.04
Y, varY = 3, 0.09
N = 3
ux = ufloat(X, math_sqrt(varX))
uy = ufloat(Y, math_sqrt(varY))
def _compare(result, u):
Z, varZ = result
assert abs(Z-u.n)/u.n < 1e-13 and (varZ-u.s**2)/u.s**2 < 1e-13, \
"expected (%g,%g) got (%g,%g)"%(u.n, u.s**2, Z, varZ)
def _check_pow(u):
_compare(pow(X, varX, N), u)
def _check_unary(op, u):
_compare(op(X, varX), u)
def _check_binary(op, u):
_compare(op(X, varX, Y, varY), u)
_check_pow(ux**N)
_check_binary(add, ux + uy)
_check_binary(sub, ux - uy)
_check_binary(mul, ux * uy)
_check_binary(div, ux / uy)
_check_binary(pow2, ux**uy)
_check_unary(exp, umath.exp(ux))
_check_unary(log, umath.log(ux))
_check_unary(sin, umath.sin(ux))
_check_unary(cos, umath.cos(ux))
_check_unary(tan, umath.tan(ux))
_check_unary(arcsin, umath.asin(ux))
_check_unary(arccos, umath.acos(ux))
_check_unary(arctan, umath.atan(ux))
_check_binary(arctan2, umath.atan2(ux, uy))
def transit_duration(P, Rp, a, b=0, e=0, w=90, inc=None, total=True):
"""
Function to calculate the total (T14) or full (T23) transit duration
Parameters:
----------
P: Period of planet orbit in days
Rp: Radius of the planet in units of stellar radius
b: Impact parameter of the planet transit [0, 1+Rp]
a: scaled semi-major axis of the planet in units of solar radius
inc: inclination of the orbit. Optional. If given b is not used. if None, b is used to calculate inc
total: if True calculate the the total transit duration T14, else calculate duration of full transit T23
Returns
-------
Tdur: duration of transit in same unit as P
"""
#eqn 30 and 31 of Kipping 2010 https://doi.org/10.1111/j.1365-2966.2010.16894.x
factor = (1-e**2)/(1+e*sin(radians(w)))
if inc == None:
inc = inclination(b,a,e,w)
if total is False:
Rp = -Rp
sini = sin(radians(inc))
cosi = cos(radians(inc))
denom = a*factor*sini
tdur= (P/np.pi) * (factor**2/sqrt(1-e**2)) * (asin ( sqrt((1+Rp)**2 - (a*factor*cosi)**2)/ denom ) )
return tdur
def CartToSphU(cn, ce, cd):
'''
CartToSphU converts from Cartesian to spherical coordinates
CartToSphU(cn,ce,cd) returns the trend (trd)
and plunge (plg) of a line for input north (cn),
east (ce), and down (cd) direction cosines.
Notice that the input direction cosines have uncertainties
NOTE: Trend and plunge are returned in radians and they
have uncertainties in radians
CartToSphU uses function ZeroTwoPi
It also uses the uncertainties package from
Eric O. Lebigot
Based on Python function CartToSph
'''
pi = math.pi
# Plunge
plg = umath.asin(cd) # Eq. 4.13a
# Trend: If north direction cosine is zero, trend
# is east or west. Choose which one by the sign of
# the east direction cosine
if cn == 0.0:
if ce < 0.0:
trd = 3.0 / 2.0 * pi # Eq. 4.14d, trend is west
else:
trd = pi / 2.0 # Eq. 4.14c, trend is east
# Else
else:
trd = umath.atan(ce / cn) # Eq. 4.14a
if cn < 0.0:
# Add pi
trd = trd + pi # Eq. 4.14b
# Make sure trend is between 0 and 2*pi
trd = ZeroTwoPi(trd)
return trd, plg
def calculate_l1_l2(h6, h7, d5, d6, l):
'''Returns the distance along (l2) and perpendicular (l1) to the steer axis from the
front wheel center to the handlebar reference point.
Parameters
----------
h6 : float
Distance from the table to the top of the front axle.
h7 : float
Distance from the table to the top of the handlebar reference circle.
d5 : float
Diameter of the front axle.
d6 : float
Diameter of the handlebar reference circle.
l : float
Outer distance from the front axle to the handlebar reference circle.
Returns
-------
l1 : float
The distance from the front wheel center to the handlebar reference
center perpendicular to the steer axis. The positive sense is if the
handlebar reference point is more forward than the front wheel center
relative to the steer axis normal.
l2 : float
The distance from the front wheel center to the handlebar reference
center parallel to the steer axis. The positive sense is if the
handlebar reference point is above the front wheel center with reference
to the steer axis.
'''
r5 = d5 / 2.
r6 = d6 / 2.
l1 = h7 - h6 + r5 - r6
l0 = l - r5 - r6
gamma = umath.asin(l1 / l0)
l2 = l0 * umath.cos(gamma)
return l1, l2
def calculate_l1_l2(h6, h7, d5, d6, l):
'''Returns the distance along (l2) and perpendicular (l1) to the steer axis from the
front wheel center to the handlebar reference point.
Parameters
----------
h6 : float
Distance from the table to the top of the front axle.
h7 : float
Distance from the table to the top of the handlebar reference circle.
d5 : float
Diameter of the front axle.
d6 : float
Diameter of the handlebar reference circle.
l : float
Outer distance from the front axle to the handlebar reference circle.
Returns
-------
l1 : float
The distance from the front wheel center to the handlebar reference
center perpendicular to the steer axis. The positive sense is if the
handlebar reference point is more forward than the front wheel center
relative to the steer axis normal.
l2 : float
The distance from the front wheel center to the handlebar reference
center parallel to the steer axis. The positive sense is if the
handlebar reference point is above the front wheel center with reference
to the steer axis.
'''
r5 = d5 / 2.
r6 = d6 / 2.
l1 = h7 - h6 + r5 - r6
l0 = l - r5 - r6
gamma = umath.asin(l1 / l0)
l2 = l0 * umath.cos(gamma)
return l1, l2
else:
try:
__x = InterpretNum(__s, Dict(locals()))
return __x
except Exception as e:
print("Number not correct: %s" % str(e))
# To utilize Marv's code, here are definitions for the macros and
# constants/variables he uses.
ABS = abs
SGN = lambda a: -1 if a < 0 else 0 if a == 0 else 1
DPR = 180/pi
RPD = pi/180
COSD = lambda a: cos(a*RPD)
SIND = lambda a: sin(a*RPD)
ASND = lambda a: DPR*asin(a if abs(a) < 1 else SGN(a))
ACSD = lambda a: DPR*acos(a if abs(a) < 1 else SGN(a))
def Calculate(__vars, __d):
# Get vars into our local namespace
if __vars is not None:
for __k in __vars:
if len(__k) > 2 and __k[:2] == "__":
continue
exec("%s = __vars['%s']" % (__k, __k))
try:
if radius and angle:
if dbg:
print("radius, angle", sig(radius), sig(angle))
z = radius*COSD(0.5*angle)
height = radius - z
def get_summary(self, nodmx=False):
"""Return a human-readable summary of the Fitter results.
Parameters
----------
nodmx : bool
Set to True to suppress printing DMX parameters in summary
"""
# Need to check that fit has been done first!
if not hasattr(self, "covariance_matrix"):
log.warning(
"fit_toas() has not been run, so pre-fit and post-fit will be the same!"
)
from uncertainties import ufloat
import uncertainties.umath as um
# First, print fit quality metrics
s = "Fitted model using {} method with {} free parameters to {} TOAs\n".format(
self.method, len(self.get_fitparams()), self.toas.ntoas)
s += "Prefit residuals Wrms = {}, Postfit residuals Wrms = {}\n".format(
self.resids_init.rms_weighted(), self.resids.rms_weighted())
s += "Chisq = {:.3f} for {} d.o.f. for reduced Chisq of {:.3f}\n".format(
self.resids.chi2, self.resids.dof, self.resids.chi2_reduced)
s += "\n"
# Next, print the model parameters
s += "{:<14s} {:^20s} {:^28s} {}\n".format("PAR", "Prefit", "Postfit",
"Units")
s += "{:<14s} {:>20s} {:>28s} {}\n".format("=" * 14, "=" * 20,
"=" * 28, "=" * 5)
for pn in list(self.get_allparams().keys()):
if nodmx and pn.startswith("DMX"):
continue
prefitpar = getattr(self.model_init, pn)
par = getattr(self.model, pn)
if par.value is not None:
if isinstance(par, strParameter):
s += "{:14s} {:>20s} {:28s} {}\n".format(
pn, prefitpar.value, "", par.units)
elif isinstance(par, AngleParameter):
# Add special handling here to put uncertainty into arcsec
if par.frozen:
s += "{:14s} {:>20s} {:>28s} {} \n".format(
pn, str(prefitpar.quantity), "", par.units)
else:
if par.units == u.hourangle:
uncertainty_unit = pint.hourangle_second
else:
uncertainty_unit = u.arcsec
s += "{:14s} {:>20s} {:>16s} +/- {:.2g} \n".format(
pn,
str(prefitpar.quantity),
str(par.quantity),
par.uncertainty.to(uncertainty_unit),
)
else:
# Assume a numerical parameter
if par.frozen:
s += "{:14s} {:20g} {:28s} {} \n".format(
pn, prefitpar.value, "", par.units)
else:
# s += "{:14s} {:20g} {:20g} {:20.2g} {} \n".format(
# pn,
# prefitpar.value,
# par.value,
# par.uncertainty.value,
# par.units,
# )
s += "{:14s} {:20g} {:28SP} {} \n".format(
pn,
prefitpar.value,
ufloat(par.value, par.uncertainty.value),
par.units,
)
# Now print some useful derived parameters
s += "\nDerived Parameters:\n"
if hasattr(self.model, "F0"):
F0 = self.model.F0.quantity
if not self.model.F0.frozen:
p, perr = pint.utils.pferrs(F0, self.model.F0.uncertainty)
s += "Period = {} +/- {}\n".format(p.to(u.s), perr.to(u.s))
else:
s += "Period = {}\n".format((1.0 / F0).to(u.s))
if hasattr(self.model, "F1"):
F1 = self.model.F1.quantity
if not any([self.model.F1.frozen, self.model.F0.frozen]):
p, perr, pd, pderr = pint.utils.pferrs(
F0, self.model.F0.uncertainty, F1,
self.model.F1.uncertainty)
s += "Pdot = {} +/- {}\n".format(
pd.to(u.dimensionless_unscaled),
pderr.to(u.dimensionless_unscaled))
brakingindex = 3
s += "Characteristic age = {:.4g} (braking index = {})\n".format(
pint.utils.pulsar_age(F0, F1, n=brakingindex),
brakingindex)
s += "Surface magnetic field = {:.3g}\n".format(
pint.utils.pulsar_B(F0, F1))
s += "Magnetic field at light cylinder = {:.4g}\n".format(
pint.utils.pulsar_B_lightcyl(F0, F1))
I_NS = I = 1.0e45 * u.g * u.cm**2
s += "Spindown Edot = {:.4g} (I={})\n".format(
pint.utils.pulsar_edot(F0, F1, I=I_NS), I_NS)
if hasattr(self.model, "PX"):
if not self.model.PX.frozen:
s += "\n"
px = ufloat(
self.model.PX.quantity.to(u.arcsec).value,
self.model.PX.uncertainty.to(u.arcsec).value,
)
s += "Parallax distance = {:.3uP} pc\n".format(1.0 / px)
# Now binary system derived parameters
binary = None
for x in self.model.components:
if x.startswith("Binary"):
binary = x
if binary is not None:
s += "\n"
s += "Binary model {}\n".format(binary)
if binary.startswith("BinaryELL1"):
if not any([
self.model.EPS1.frozen,
self.model.EPS2.frozen,
self.model.TASC.frozen,
self.model.PB.frozen,
]):
eps1 = ufloat(
self.model.EPS1.quantity.value,
self.model.EPS1.uncertainty.value,
)
eps2 = ufloat(
self.model.EPS2.quantity.value,
self.model.EPS2.uncertainty.value,
)
tasc = ufloat(
# This is a time in MJD
self.model.TASC.quantity.mjd,
self.model.TASC.uncertainty.to(u.d).value,
)
pb = ufloat(
self.model.PB.quantity.to(u.d).value,
self.model.PB.uncertainty.to(u.d).value,
)
s += "Conversion from ELL1 parameters:\n"
ecc = um.sqrt(eps1**2 + eps2**2)
s += "ECC = {:P}\n".format(ecc)
om = um.atan2(eps1, eps2) * 180.0 / np.pi
if om < 0.0:
om += 360.0
s += "OM = {:P}\n".format(om)
t0 = tasc + pb * om / 360.0
s += "T0 = {:SP}\n".format(t0)
s += pint.utils.ELL1_check(
self.model.A1.quantity,
ecc.nominal_value,
self.resids.rms_weighted(),
self.toas.ntoas,
outstring=True,
)
s += "\n"
# Masses and inclination
if not any([self.model.PB.frozen, self.model.A1.frozen]):
pbs = ufloat(
self.model.PB.quantity.to(u.s).value,
self.model.PB.uncertainty.to(u.s).value,
)
a1 = ufloat(
self.model.A1.quantity.to(pint.ls).value,
self.model.A1.uncertainty.to(pint.ls).value,
)
fm = 4.0 * np.pi**2 * a1**3 / (4.925490947e-6 * pbs**2)
s += "Mass function = {:SP} Msun\n".format(fm)
mcmed = pint.utils.companion_mass(
self.model.PB.quantity,
self.model.A1.quantity,
inc=60.0 * u.deg,
mpsr=1.4 * u.solMass,
)
mcmin = pint.utils.companion_mass(
self.model.PB.quantity,
self.model.A1.quantity,
inc=90.0 * u.deg,
mpsr=1.4 * u.solMass,
)
s += "Companion mass min, median (assuming Mpsr = 1.4 Msun) = {:.4f}, {:.4f} Msun\n".format(
mcmin, mcmed)
if hasattr(self.model, "SINI"):
if not self.model.SINI.frozen:
si = ufloat(
self.model.SINI.quantity.value,
self.model.SINI.uncertainty.value,
)
s += "From SINI in model:\n"
s += " cos(i) = {:SP}\n".format(um.sqrt(1 - si**2))
s += " i = {:SP} deg\n".format(
um.asin(si) * 180.0 / np.pi)
psrmass = pint.utils.pulsar_mass(
self.model.PB.quantity,
self.model.A1.quantity,
self.model.M2.quantity,
np.arcsin(self.model.SINI.quantity),
)
s += "Pulsar mass (Shapiro Delay) = {}".format(psrmass)
return s
def Test():
'''The following test cases came from the sample problems at
http://www.mathsisfun.com/algebra/trig-solving-triangles.html
'''
eps, r2d, d2r = 1e-14, 180/pi, pi/180
d = {
"angle_measure" : d2r,
}
# sss
d["vars"] = {
"S1" : 6,
"S2" : 7,
"S3" : 8,
}
d["problem_type"] = "sss"
SolveProblem(d)
k = d["solution"]
assert abs(k["A1"] - acos(77/112)) < eps
assert abs(k["A2"] - (pi - k["A3"] - k["A1"])) < eps
assert abs(k["A3"] - acos(1/4)) < eps
# ssa
d["vars"] = {
"S1" : 8,
"S2" : 13,
"A1" : 31, # Angle in degrees
}
d["problem_type"] = "ssa"
SolveProblem(d)
k = d["solution"]
a2 = asin(13*sin(31*d2r)/8)
assert abs(k["A2"] - a2) < eps
a3 = pi - k["A2"] - k["A1"]
assert abs(k["A3"] - a3) < eps
assert abs(k["S3"] - sin(a3)*8/sin(31*d2r)) < eps
# Check other solution
a2_2 = pi - asin(13*sin(31*d2r)/8)
assert abs(k["A2_2"] - a2_2) < eps
a3_2 = pi - k["A2_2"] - k["A1_2"]
assert abs(k["A3_2"] - a3_2) < eps
assert abs(k["S3_2"] - sin(a3_2)*8/sin(31*d2r)) < eps
# sas
d["vars"] = {
"S1" : 5,
"S2" : 7,
"A1" : 49, # Angle in degrees
}
d["problem_type"] = "sas"
SolveProblem(d)
k = d["solution"]
# asa
d["vars"] = {
"S1" : 9,
"A1" : 76, # Angle in degrees
"A2" : 34, # Angle in degrees
}
d["problem_type"] = "asa"
SolveProblem(d)
k = d["solution"]
assert abs(k["S2"] - 9*sin(34*d2r)/sin(70*d2r)) < eps
assert abs(k["S1"] - 9*sin(76*d2r)/sin(70*d2r)) < eps
assert abs(k["A3"] - 70*d2r) < eps
# saa
d["vars"] = {
"S1" : 7,
"A1" : 62, # Angle in degrees
"A2" : 35, # Angle in degrees
}
d["problem_type"] = "saa"
SolveProblem(d)
k = d["solution"]
assert abs(k["A3"] - 83*d2r) < eps
assert abs(k["S2"] - 7*sin(35*d2r)/sin(62*d2r)) < eps
assert abs(k["S3"] - 7*sin(83*d2r)/sin(62*d2r)) < eps
out("Tests passed")
def SolveProblem(d):
# Get our needed variables
for k in d["vars"]:
if k in set(("S1", "S2", "S3", "A1", "A2", "A3")):
exec("%s = d['vars']['%s']" % (k, k))
angle_conv = d["angle_measure"] # Converts angle measure to radians
prob = d["problem_type"]
try:
if prob == "sss":
# Law of cosines to find two angles, angle law to find third.
A1 = acos((S2**2 + S3**2 - S1**2)/(2*S2*S3))
A2 = acos((S1**2 + S3**2 - S2**2)/(2*S1*S3))
A3 = pi - A1 - A2
elif prob == "ssa":
# Law of sines to find the other two angles and remaining
# side. Note it can have two solutions (the second solution's
# data will be in the variables s1_2, s2_2, etc.).
A1 *= angle_conv # Make sure angle is in radians
A2 = asin((S2/S1*sin(A1)))
A3 = pi - A1 - A2
S3 = S2*sin(A3)/sin(A2)
# Check for other solution
A1_2 = A1
A2_2 = pi - A2
A3_2 = pi - A1_2 - A2_2
if A1_2 + A2_2 + A3_2 > pi:
# Second solution not possible
del A1_2
del A2_2
del A3_2
else:
# Second solution is possible
S1_2 = S1
S2_2 = S2
S3_2 = S2_2*sin(A3_2)/sin(A2_2)
elif prob == "sas":
# Law of cosines to find third side; law of sines to find
# another angle; angle law for other angle. Note we rename
# the incoming angle to be consistent with a solution diagram.
A3 = A1*angle_conv # Make sure angle is in radians
S3 = sqrt(S1**2 + S2**2 - 2*S1*S2*cos(A3))
A2 = asin(S2*sin(A3)/S3)
A1 = pi - A2 - A3
elif prob == "asa":
# Third angle from angle law; law of sines for other two
# sides. Note we rename the sides for consistency with a
# diagram.
A1 *= angle_conv # Make sure angle is in radians
A2 *= angle_conv # Make sure angle is in radians
A3 = pi - A1 - A2
S3 = S1
S2 = S3*sin(A2)/sin(A3)
S1 = S3*sin(A1)/sin(A3)
elif prob == "saa":
# Third angle from angle law; law of sines for other two
# sides.
A1 *= angle_conv # Make sure angle is in radians
A2 *= angle_conv # Make sure angle is in radians
A3 = pi - A1 - A2
S2 = S1*sin(A2)/sin(A1)
S3 = S1*sin(A3)/sin(A1)
else:
raise ValueError("Bug: unrecognized problem")
except UnboundLocalError as e:
s = str(e)
loc = s.find("'")
s = s[loc + 1:]
loc = s.find("'")
s = s[:loc]
Error("Variable '%s' not defined" % s)
except ValueError as e:
msg = "Can't solve the problem:\n"
msg += " Error: %s" % str(e)
Error(msg)
# Collect solution information
solution = {}
vars = set((
"S1", "S2", "S3", "A1", "A2", "A3",
"S1_2", "S2_2", "S3_2", "A1_2", "A2_2", "A3_2",
))
for k in vars:
if k in locals():
exec("solution['%s'] = %s" % (k, k))
d["solution"] = solution
