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')