def test_compound_fitting_with_units():
x = np.linspace(-5, 5, 15) * u.Angstrom
y = np.linspace(-5, 5, 15) * u.Angstrom
fitter = fitting.LevMarLSQFitter()
m = models.Gaussian2D(10*u.Hz,
3*u.Angstrom, 4*u.Angstrom,
1*u.Angstrom, 2*u.Angstrom)
p = models.Planar2D(3*u.Hz/u.Angstrom, 4*u.Hz/u.Angstrom, 1*u.Hz)
model = m + p
z = model(x, y)
res = fitter(model, x, y, z)
assert isinstance(res(x, y), np.ndarray)
assert all([res[i]._has_units for i in range(2)])
model = models.Gaussian2D() + models.Planar2D()
res = fitter(model, x, y, z)
assert isinstance(res(x, y), np.ndarray)
assert all([res[i]._has_units for i in range(2)])
# A case of a mixture of models with and without units
model = models.BlackBody(temperature=3000 * u.K) * models.Const1D(amplitude=1.0)
x = np.linspace(1, 3, 10000) * u.micron
with NumpyRNGContext(12345):
n = np.random.normal(3)
y = model(x)
res = fitter(model, x, y * (1 + n))
# The large rtol here is due to different results on linux and macosx, likely
# the model is ill-conditioned.
np.testing.assert_allclose(res.parameters, [3000, 2.1433621e+00, 2.647347e+00], rtol=0.4)
def test_normalized_bb(NGC4945_continuum):
n_black = nd.normalized_blackbody(T=1200)
n_inst = n_black(NGC4945_continuum.frequency_axis.value)
a_blackbody = models.BlackBody(1200 * u.K)
a_instance = a_blackbody(NGC4945_continuum.frequency_axis)
expected = a_instance / np.mean(a_instance)
np.testing.assert_almost_equal(n_inst[200], expected[200].value, decimal=7)
def test_coerce_units():
model = models.Polynomial1D(1, c0=1, c1=2)
with pytest.raises(u.UnitsError):
model(u.Quantity(10, u.m))
with_input_units = model.coerce_units({"x": u.m})
result = with_input_units(u.Quantity(10, u.m))
assert np.isclose(result, 21.0)
with_input_units_tuple = model.coerce_units((u.m, ))
result = with_input_units_tuple(u.Quantity(10, u.m))
assert np.isclose(result, 21.0)
with_return_units = model.coerce_units(return_units={"y": u.s})
result = with_return_units(10)
assert np.isclose(result.value, 21.0)
assert result.unit == u.s
with_return_units_tuple = model.coerce_units(return_units=(u.s, ))
result = with_return_units_tuple(10)
assert np.isclose(result.value, 21.0)
assert result.unit == u.s
with_both = model.coerce_units({"x": u.m}, {"y": u.s})
result = with_both(u.Quantity(10, u.m))
assert np.isclose(result.value, 21.0)
assert result.unit == u.s
with pytest.raises(ValueError,
match=r"input_units keys.*do not match model inputs"):
model.coerce_units({"q": u.m})
with pytest.raises(ValueError,
match=r"input_units length does not match n_inputs"):
model.coerce_units((u.m, u.s))
model_with_existing_input_units = models.BlackBody()
with pytest.raises(
ValueError,
match=
r"Cannot specify input_units for model with existing input units"):
model_with_existing_input_units.coerce_units({"x": u.m})
with pytest.raises(ValueError,
match=r"return_units keys.*do not match model outputs"):
model.coerce_units(return_units={"q": u.m})
with pytest.raises(ValueError,
match=r"return_units length does not match n_outputs"):
model.coerce_units(return_units=(u.m, u.s))
ellip=0.0,
theta=0.0),
astmodels.Sine1D(amplitude=10., frequency=0.5, phase=1.),
astmodels.Cosine1D(amplitude=10., frequency=0.5, phase=1.),
astmodels.Tangent1D(amplitude=10., frequency=0.5, phase=1.),
astmodels.ArcSine1D(amplitude=10., frequency=0.5, phase=1.),
astmodels.ArcCosine1D(amplitude=10., frequency=0.5, phase=1.),
astmodels.ArcTangent1D(amplitude=10., frequency=0.5, phase=1.),
astmodels.Trapezoid1D(amplitude=10., x_0=0.5, width=5., slope=1.),
astmodels.TrapezoidDisk2D(amplitude=10.,
x_0=0.5,
y_0=1.5,
R_0=5.,
slope=1.),
astmodels.Voigt1D(x_0=0.55, amplitude_L=10., fwhm_L=0.5, fwhm_G=0.9),
astmodels.BlackBody(scale=10.0, temperature=6000. * u.K),
astmodels.Drude1D(amplitude=10.0, x_0=0.5, fwhm=2.5),
astmodels.Plummer1D(mass=10.0, r_plum=5.0),
astmodels.BrokenPowerLaw1D(amplitude=10,
x_break=0.5,
alpha_1=2.0,
alpha_2=3.5),
astmodels.ExponentialCutoffPowerLaw1D(10, 0.5, 2.0, 7.),
astmodels.LogParabola1D(
amplitude=10,
x_0=0.5,
alpha=2.,
beta=3.,
),
astmodels.PowerLaw1D(amplitude=10., x_0=0.5, alpha=2.0),
astmodels.SmoothlyBrokenPowerLaw1D(amplitude=10.,
def test_flare_magnitudes_mixed_with_none(self):
"""
Test that we get the expected magnitudes out
"""
db = MLT_test_DB(database=self.db_name, driver='sqlite')
# load the quiescent SEDs of the objects in our catalog
sed_list = SedList(['lte028-5.0+0.5a+0.0.BT-Settl.spec.gz']*4,
[17.1, 17.2, 17.3, 17.4],
galacticAvList = [2.432, 1.876, 2.654, 2.364],
fileDir=getPackageDir('sims_sed_library'),
specMap=defaultSpecMap)
bp_dict = BandpassDict.loadTotalBandpassesFromFiles()
# calculate the quiescent fluxes of the objects in our catalog
baseline_fluxes = bp_dict.fluxListForSedList(sed_list)
bb_wavelen = np.arange(100.0, 1600.0, 0.1)
bb = models.BlackBody(temperature=9000.0 * u.K, scale=1.0 * u.erg / (u.cm ** 2 * u.AA * u.s * u.sr))
bb_flambda = bb(bb_wavelen * u.nm).to_value()
# this data is taken from the setUpClass() classmethod above
t0_list = [456.2, 41006.2, 117.2, 10456.2]
av_list = [2.432, 1.876, 2.654, 2.364]
parallax_list = np.array([0.25, 0.15, 0.3, 0.22])
distance_list = 1.0/(206265.0*radiansFromArcsec(0.001*parallax_list))
distance_list *= 3.0857e18 # convert to cm
dtype = np.dtype([('id', int), ('u', float), ('g', float)])
photParams = PhotometricParameters()
ss = Sed()
quiet_cat_name = os.path.join(self.scratch_dir, 'mlt_mixed_with_none_quiet_cat.txt')
flare_cat_name = os.path.join(self.scratch_dir, 'mlt_mixed_with_none_flaring_cat.txt')
# loop over several MJDs and verify that, to within a
# milli-mag, our flaring model gives us the magnitudes
# expected, given the light curves specified in
# setUpClass()
for mjd in (59580.0, 60000.0, 70000.0, 80000.0):
obs = ObservationMetaData(mjd=mjd)
quiet_cat = QuiescentCatalog(db, obs_metadata=obs)
quiet_cat.write_catalog(quiet_cat_name)
flare_cat = FlaringCatalog(db, obs_metadata=obs)
flare_cat._mlt_lc_file = self.mlt_lc_name
flare_cat.write_catalog(flare_cat_name)
quiescent_data = np.genfromtxt(quiet_cat_name, dtype=dtype, delimiter=',')
flaring_data = np.genfromtxt(flare_cat_name, dtype=dtype, delimiter=',')
self.assertGreater(len(flaring_data), 3)
for ix in range(len(flaring_data)):
obj_id = flaring_data['id'][ix]
self.assertEqual(obj_id, ix)
# the models below are as specified in the
# setUpClass() method
if obj_id == 0 or obj_id == 1:
amp = 1.0e42
dt = 3652.5
t_min = flare_cat._survey_start - t0_list[obj_id]
tt = mjd - t_min
while tt > dt:
tt -= dt
u_flux = amp*(1.0+np.power(np.sin(tt/100.0), 2))
g_flux = amp*(1.0+np.power(np.cos(tt/100.0), 2))
elif obj_id==2:
amp = 2.0e41
dt = 365.25
t_min = flare_cat._survey_start - t0_list[obj_id]
tt = mjd - t_min
while tt > dt:
tt -= dt
u_flux = amp*(1.0+np.power(np.sin(tt/50.0), 2))
g_flux = amp*(1.0+np.power(np.cos(tt/50.0), 2))
else:
u_flux = 0.0
g_flux = 0.0
# calculate the multiplicative effect of dust on a 9000K
# black body
bb_sed = Sed(wavelen=bb_wavelen, flambda=bb_flambda)
u_bb_flux = bb_sed.calcFlux(bp_dict['u'])
g_bb_flux = bb_sed.calcFlux(bp_dict['g'])
a_x, b_x = bb_sed.setupCCM_ab()
bb_sed.addDust(a_x, b_x, A_v=av_list[obj_id])
u_bb_dusty_flux = bb_sed.calcFlux(bp_dict['u'])
g_bb_dusty_flux = bb_sed.calcFlux(bp_dict['g'])
dust_u = u_bb_dusty_flux/u_bb_flux
dust_g = g_bb_dusty_flux/g_bb_flux
area = 4.0*np.pi*np.power(distance_list[obj_id], 2)
tot_u_flux = baseline_fluxes[obj_id][0] + u_flux*dust_u/area
tot_g_flux = baseline_fluxes[obj_id][1] + g_flux*dust_g/area
msg = ('failed on object %d; mjd %.2f\n u_quiet %e u_flare %e\n g_quiet %e g_flare %e' %
(obj_id, mjd, quiescent_data['u'][obj_id], flaring_data['u'][obj_id],
quiescent_data['g'][obj_id], flaring_data['g'][obj_id]))
self.assertEqual(quiescent_data['id'][obj_id], flaring_data['id'][obj_id], msg=msg)
self.assertAlmostEqual(ss.magFromFlux(baseline_fluxes[obj_id][0]),
quiescent_data['u'][obj_id], 3, msg=msg)
self.assertAlmostEqual(ss.magFromFlux(baseline_fluxes[obj_id][1]),
quiescent_data['g'][obj_id], 3, msg=msg)
self.assertAlmostEqual(ss.magFromFlux(tot_u_flux), flaring_data['u'][obj_id],
3, msg=msg)
self.assertAlmostEqual(ss.magFromFlux(tot_g_flux), flaring_data['g'][obj_id],
3, msg=msg)
if obj_id != 3:
self.assertGreater(np.abs(flaring_data['g'][obj_id]-quiescent_data['g'][obj_id]),
0.001, msg=msg)
self.assertGreater(np.abs(flaring_data['u'][obj_id]-quiescent_data['u'][obj_id]),
0.001, msg=msg)
else:
self.assertEqual(flaring_data['g'][obj_id]-quiescent_data['g'][obj_id], 0.0, msg=msg)
self.assertEqual(flaring_data['u'][obj_id]-quiescent_data['u'][obj_id], 0.0, msg=msg)
if os.path.exists(quiet_cat_name):
os.unlink(quiet_cat_name)
if os.path.exists(flare_cat_name):
os.unlink(flare_cat_name)
def calc_IQU(self,
ds,
dd,
los,
Td=18.0 * au.K,
p0=0.2,
sigmad=1e-26 * au.cm**2,
nu=353 * au.GHz):
"""
Td : Dust temperature
p0 : intrisic polarization fraction
sigmad: Dust opacity tau_353/NH ~ 1.2e-26 cm^2
(from Planck XX, DOI: 10.1051/0004-6361/201424086)
"""
axis_idx = dict(x=0, y=1, z=2)
# Follows even cyclic permutation of xyz
los = dict(z=dict(B1='Bx', B2='By', B3='Bz'),
x=dict(B1='By', B2='Bz', B3='Bx'),
y=dict(B1='Bz', B2='Bx', B3='By'))
from astropy.modeling import models
bb = models.BlackBody(temperature=Td)
Bnu = bb(nu)
I = dict()
Q = dict()
U = dict()
NH = dict()
B1proj = dict()
B2proj = dict()
for dim in los:
dx_cgs = ds.domain['dx'][axis_idx[dim]] * self.u.length.cgs.value
B1 = dd[los[dim]['B1']]
B2 = dd[los[dim]['B2']]
B3 = dd[los[dim]['B3']]
# Bperp_sq = B1*B1 + B2*B2
# cos(2phi) = (B2*B2 - B1*B1)/Bperp_sq
# sin(2phi) = -2.0*B1*B2/Bperp_sq
Bperp_sq = B1**2 + B2**2
cos_gamma_sq = Bperp_sq / (Bperp_sq + B3**2)
I[dim] = (((Bnu * sigmad * dx_cgs) * (1.0 - p0) *
(cos_gamma_sq - 2.0 / 3.0) *
dd['nH']).sum(dim=dim)).data
Q[dim] = (((Bnu * sigmad * dx_cgs) * p0 *
((B2 * B2 - B1 * B1) / Bperp_sq) * cos_gamma_sq *
dd['nH']).sum(dim=dim)).data
U[dim] = (((Bnu * sigmad * dx_cgs) * p0 *
(-2.0 * B1 * B2 / Bperp_sq) * cos_gamma_sq *
dd['nH']).sum(dim=dim)).data
# Density weighted projection
nHsum = dd['nH'].sum(dim=dim)
NH[dim] = (nHsum * dx_cgs).data
B1proj[dim] = ((B1 * dd['nH']).sum(dim=dim) / nHsum).data
B2proj[dim] = ((B2 * dd['nH']).sum(dim=dim) / nHsum).data
return dict(I=I,
Q=Q,
U=U,
NH=NH,
B1proj=B1proj,
B2proj=B2proj,
time=ds.domain['time'],
p0=p0,
Td=Td.value,
sigmad=sigmad.value,
nu=nu.value)
FuerzaGrav(1407 * u.imperial.pound, 141600000 * u.imperial.mile)
@u.quantity_input(T=u.K)
def LeyPlanck(T, nu=299792.458):
from astropy.constants import c, k_B, h
x = u.Quantity(nu, u.Hz, dtype=np.float64)
bt = (2 * h * x**3) / ((c**2) * np.expm1(h * x / (k_B * T))) / u.sr
unidades = u.erg / (u.cm**2 * u.s * u.Hz * u.sr)
return bt.to(unidades)
from astropy.modeling import models
CN = models.BlackBody(temperature=7000 * u.K)
CN(750000)
from astropy.coordinates import Angle
ra = Angle(np.array(Zwicky['ra']) * u.degree)
ra = ra.wrap_at(180 * u.degree)
dec = Angle(np.array(Zwicky['dec']) * u.degree)
fig = plt.figure()
ax = fig.add_subplot(111, projection="aitoff")
ax.scatter(ra.radian, dec.radian, s=4, alpha=.7, marker='.',\
zorder=-1, color='k')
ax.grid(True)
pag0 = 'https://heasarc.gsfc.nasa.gov/docs/rosat/survey/sxrb/'
ROSAT = fits.open(pag0 + 'rass_m.fits')
