def demo_divine_figure_10(): """Note that the figure has broken x axes! It's a bit of a hassle to try to reproduce the temperature lines going through our functions, but the fundamental computation is pretty straightforward. So we don't bother with the outer-disk temperature. """ import omega as om bc_lon = 0.0 # arbitrary since we choose lats to put us in the disk plane r_A = np.linspace(1, 9.5, 100) r_B = np.linspace(9.5, 95, 50) r_C = np.linspace(95., 170, 30) # We need to choose coordinates fairly precisely to stay in the disk # midplane, which appears to be what DG83 plot. bc_lat_A = equatorial_latitude(bc_lon, r_A) bc_lat_B = equatorial_latitude(bc_lon, r_B) bc_lat_C = equatorial_latitude(bc_lon, r_C) N_A, kT_A = cold_e_maxwellian_parameters(bc_lat_A, bc_lon, r_A) N_B, kT_B = cold_e_maxwellian_parameters(bc_lat_B, bc_lon, r_B) N_C, kT_C = cold_e_maxwellian_parameters(bc_lat_C, bc_lon, r_C) kT_A *= 1e6 # MeV => eV kT_B *= 1e6 kT_C *= 1e6 hb = om.layout.HBox(3) hb.setWeight(2, 0.5) hb[0] = om.quickXY(r_A, N_A, 'n_e (cm^-3)') hb[0].addXY(r_A, kT_A, 'kT (eV)') hb[0].setLinLogAxes(False, True) hb[0].setBounds(1, 9.5, 3e-4, 3e4) hb[0].setYLabel('Density or temperature') hb[1] = om.quickXY(r_B, N_B, None) hb[1].addXY(r_B, kT_B, None) hb[1].setLinLogAxes(False, True) hb[1].setBounds(9.5, 95, 3e-4, 3e4) hb[1].lpainter.paintLabels = False hb[1].setXLabel('Jovicentric distance') hb[2] = om.quickXY(r_C, N_C, None) hb[2].addXY(r_C, kT_C, None) hb[2].setLinLogAxes(False, True) hb[2].setBounds(95, 170, 3e-4, 3e4) hb[2].lpainter.paintLabels = False return hb
def plotUVDs(self): import omega from bisect import bisect d = ArrayGrower(2) bpd = self.ccs[0].bpData idxs = xrange(0, len(bpd)) for bp, uvdsa in self.uvdists.iteritems(): uvd = uvdsa.mean() * 0.001 # FIXME: slooooooow for i in idxs: if bpd[i][0] == bp: break else: continue val = bpd[i][1] d.add(uvd, val) d = d.finish() p = omega.quickXY(d[:, 0], d[:, 1], 'Closure values', lines=False) p.setLabels('UV Distance (kilolambda)', '%s closure' % self.ccs[0].item) return p
def make_figure9_plot(shlib_path, use_lowlevel=True, **kwargs): """Reproduce Figure 9 of the Fleischman & Kuznetsov (2010) paper, using our low-level interfaces. Uses OmegaPlot, of course. Input parameters, etc., come from the file ``Flare071231a.pro`` that is distributed with the paper’s Supplementary Data archive. Invoke with something like:: from pwkit import fk10 fk10.make_figure9_plot('path/to/libGS_Std_HomSrc_CEH.so.64').show() """ import omega as om if use_lowlevel: out_vals = do_figure9_calc_lowlevel(shlib_path, **kwargs) else: out_vals = do_figure9_calc_highlevel(shlib_path, **kwargs) freqs = out_vals[:, OUT_VAL_FREQ] tot_ints = out_vals[:, OUT_VAL_OINT] + out_vals[:, OUT_VAL_XINT] pos = (tot_ints > 0) p = om.quickXY(freqs[pos], tot_ints[pos], 'Calculation', xlog=1, ylog=1) nu_obs = np.array([1.0, 2.0, 3.75, 9.4, 17.0, 34.0]) int_obs = np.array([12.0, 43.0, 29.0, 6.3, 1.7, 0.5]) p.addXY(nu_obs, int_obs, 'Observations', lines=False) p.defaultKeyOverlay.hAlign = 0.93 p.setBounds(0.5, 47, 0.1, 60) p.setLabels('Emission frequency, GHz', 'Total intensity, sfu') return p
def plot_lightcurve (self, ccd_id=None, bin_energies=False): # XXX CIAO COPY/PASTE DOES THIS EVEN WORK??? import omega as om from ...bblocks import tt_bblock from ..ciao.data import tight_bounds if ccd_id is None: if len (self.gti) != 1: raise Exception ('must specify ccd_id') ccd_id = list(self.gti.keys())[0] kev = self.events['pi'] * 1e-3 # XXXXXXX vb = om.layout.VBox (2) if kev.size == 0: vb[0] = om.RectPlot() vb[1] = om.RectPlot() tmin = self.gti[ccd_id]['start_dmjd'].min() tmax = self.gti[ccd_id]['stop_dmjd'].max() if np.isnan(tmin): tmin, tmax = -1., 1. emin, emax = -1., 1. rmin, rmax = -1., 1. else: bbinfo = tt_bblock ( self.gti[ccd_id]['start_dmjd'], self.gti[ccd_id]['stop_dmjd'], self.events['dmjd'].sort_values(), intersect_with_bins = True, ) cps = bbinfo.rates / 86400 tmin, tmax = tight_bounds (bbinfo.ledges[0], bbinfo.redges[-1]) emin, emax = tight_bounds (kev.min (), kev.max ()) rmin, rmax = tight_bounds (cps.min (), cps.max ()) vb[0] = om.RectPlot () csp = om.rect.ContinuousSteppedPainter (keyText='%d events' % (self.events.shape[0])) csp.setFloats (np.concatenate ((bbinfo.ledges, bbinfo.redges[-1:])), np.concatenate ((cps, [0]))) vb[0].add (csp) if bin_energies: vb[1] = self._plot_binned_event_energies( bbinfo, energy_scale = 1e-3, dsn = 0 ) else: vb[1] = om.quickXY (self.events['dmjd'], kev, None, lines=0) vb[0].setBounds (tmin, tmax, rmin, rmax) vb[0].setYLabel ('Count rate (ct/s)') vb[0].bpainter.paintLabels = False self._plot_add_gtis (vb[0], ccd_id) vb[1].setBounds (tmin, tmax, emin, emax) vb[1].setLabels ('MJD - %d' % self.mjd0, 'Energy (keV)') self._plot_add_gtis (vb[1], ccd_id) return vb
def plotUVDs (self): import omega from bisect import bisect d = ArrayGrower (2) bpd = self.ccs[0].bpData idxs = xrange (0, len (bpd)) for bp, uvdsa in self.uvdists.iteritems (): uvd = uvdsa.mean () * 0.001 # FIXME: slooooooow for i in idxs: if bpd[i][0] == bp: break else: continue val = bpd[i][1] d.add (uvd, val) d = d.finish () p = omega.quickXY (d[:,0], d[:,1], 'Closure values', lines=False) p.setLabels ('UV Distance (kilolambda)', '%s closure' % self.ccs[0].item) return p
def shprits06_figure_1(kev=300): import omega as om alpha_star = 0.16 # = 2.5**-2 E = kev / 511 # normalized to 511 keV x_m = 0.35 delta_x = 0.15 B_wave = 0.1 # nT max_wave_lat = 15 * np.pi / 180 # Omega_e = e B / m_e c for equatorial B at L = 3.5. B ~ B_surf * L**-3. # # In Summers 2005, at L = 4.5 f_ce = Omega_e/2pi = 9.54 kHz, implying # Omega_e = 59.9 rad/s and B_eq = 3.41 mG = 340 nT. Therefore B0 = 31056 # nT. Extrapolating to L = 3.5, we get the following. (Shorter version: # Omega_e(L2) = Omega_e(L1) * (L1/L2)**3.) Omega_e = 127400. # R = (Delta B / B)**2. At fixed Delta B, R(L2) = R(L1) * (L2/L1)**6 R = 1.9e-8 degrees = np.linspace(2, 87, 100) sinas = np.sin(degrees * np.pi / 180) Daa = compute(E, sinas, Omega_e, alpha_star, R, x_m, delta_x, 'R', max_wave_lat, p_scaled=True)[0] Dee = compute_dee_on_e2(E, sinas, Omega_e, alpha_star, R, x_m, delta_x, max_wave_lat, 'R') hb = om.layout.HBox(2) pee = hb[0] = om.quickXY(degrees, Dee, str(kev), ylog=True) paa = hb[1] = om.quickXY(degrees, Daa, str(kev), ylog=True) pee.setBounds(0, 90, 1e-7, 0.1) paa.setBounds(0, 90, 1e-7, 0.1) return hb
def ellplot(maj, min, pa): """Utility for debugging.""" _ellcheck(maj, min, pa) import omega as om th = np.linspace(0, 2 * np.pi, 200) x, y = ellpoint(maj, min, pa, th) return om.quickXY(x, y, 'maj=%f min=%f pa=%f' % (maj, min, pa * 180 / np.pi))
def ellplot (mjr, mnr, pa): """Utility for debugging.""" _ellcheck (mjr, mnr, pa) import omega as om th = np.linspace (0, 2 * np.pi, 200) x, y = ellpoint (mjr, mnr, pa, th) return om.quickXY (x, y, 'mjr=%f mnr=%f pa=%f' % (mjr, mnr, pa * 180 / np.pi))
def plot_cube(self, c): import omega as om med_g = np.median(c, axis=(1, 2)) med_a = np.median(c, axis=(0, 2)) med_l = np.median(c, axis=(0, 1)) mn = min(med_g.min(), med_a.min(), med_l.min()) mx = max(med_g.max(), med_a.max(), med_l.max()) delta = abs(mx - mn) * 0.02 mx += delta mn -= delta hb = om.layout.HBox(3) hb[0] = om.quickXY(self.g_edges, med_g, u'g', ymin=mn, ymax=mx) hb[1] = om.quickXY(self.alpha_edges, med_a, u'α', ymin=mn, ymax=mx) hb[1].lpainter.paintLabels = False hb[2] = om.quickXY(self.L_edges, med_l, u'L', ymin=mn, ymax=mx) hb[2].lpainter.paintLabels = False hb.setWeight(0, 1.1) # extra room for labels return hb
def view_lc_cli(args): import omega as om settings = make_view_lc_parser().parse_args(args=args) ii = IntegratedImages(settings.path) lc = ii.lightcurve(settings.ifreq, settings.stokes) desc = '%s freq=%.2f stokes=%s' % (settings.path, ii.freqs[settings.ifreq], settings.stokes) p = om.quickXY(ii.cmls, lc, None) p.setLabels('CML (deg)', '%s (uJy)' % desc) p.show()
def ns_plot(self, param_index, plot_err=False, to_phys=False, thin=100): """Make a diagnostic plot comparing the approximation to the "actual" results from the calculator. """ import omega as om par, act, nn = self.ns_validate(filter=True, to_phys=to_phys) if plot_err: err = nn - act p = om.quickXY(par[::thin, param_index], err[::thin], 'Error', lines=0) else: p = om.quickXY(par[::thin, param_index], act[::thin], 'Full calc', lines=0) p.addXY(par[::thin, param_index], nn[::thin], 'Neural', lines=0) return p
def main(): """Following the discussion of appropriate values of the timestep (delta_s) in Du Toit Strauss (arxiv:1703.06192), in our problem a sensible target length scale would be l = 0.1, leading to delta_s = 0.0025 . This doesn't give amazingly accurate answers; l = 0.01 is noticeably better, at a big runtime penalty, of course. """ x0s, results = calculate(10, n_pcle=1024, delta_s=0.0025) p = om.quickXY([0., 1.], [0., 1.], 'Analytic') p.addXY(x0s, results, 'SDE', lines=False) p.setLabels('x', 'Distribution function') p.show()
def plot_lightcurve (self, ccd_id=None): import omega as om from ...bblocks import tt_bblock if ccd_id is None: if len (self.gti) != 1: raise Exception ('must specify ccd_id') ccd_id = self.gti.keys ()[0] kev = self.events['energy'] * 1e-3 bbinfo = tt_bblock ( self.gti[ccd_id]['start_dmjd'], self.gti[ccd_id]['stop_dmjd'], self.events['dmjd'] ) cps = bbinfo.rates / 86400 tmin, tmax = tight_bounds (bbinfo.ledges[0], bbinfo.redges[-1]) emin, emax = tight_bounds (kev.min (), kev.max ()) rmin, rmax = tight_bounds (cps.min (), cps.max ()) vb = om.layout.VBox (2) vb[0] = om.RectPlot () csp = om.rect.ContinuousSteppedPainter (keyText='%d events' % (self.events.shape[0])) csp.setFloats (np.concatenate ((bbinfo.ledges, bbinfo.redges[-1:])), np.concatenate ((cps, [0]))) vb[0].add (csp) vb[0].setBounds (tmin, tmax, rmin, rmax) vb[0].setYLabel ('Count rate (ct/s)') vb[0].bpainter.paintLabels = False self._plot_add_gtis (vb[0], ccd_id) vb[1] = om.quickXY (self.events['dmjd'], kev, None, lines=0) vb[1].setBounds (tmin, tmax, emin, emax) vb[1].setLabels ('MJD - %d' % self.mjd0, 'Energy (keV)') self._plot_add_gtis (vb[1], ccd_id) return vb
def demo_divine_figure_1(): """The outer radii in my plot do not resemble D&G's Figure 1, but the power laws show that my values are scaling as intended. Therefore I guess that the figure is just somewhat inaccurate. """ import omega as om L = np.logspace(np.log10(1.), np.log10(200), 100) d4 = JupiterD4Field() dc_lat = 0. dc_lon = 0. dc_r = L * np.cos(dc_lat)**2 bc = d4._from_dc(dc_lat, dc_lon, dc_r) bmag = d4.bmag(*bc) bmag *= G2NT bcut = B_cutoff(L) * G2NT r0_inner = 1. b0_inner = d4.bmag(0., 0., r0_inner) * G2NT r_inner = np.logspace(0, 1, 5) b_inner = b0_inner * (r_inner / r0_inner)**-3 r0_outer = 20. b0_outer = d4.bmag(0., 0., r0_outer) * G2NT r_outer = np.logspace(1, 2.5, 5) b_outer = b0_outer * (r_outer / r0_outer)**-1.6 p = om.quickXY(L, bmag, 'Eq field strength', xlog=True, ylog=True) p.addXY(L, bcut, 'B_cutoff') p.addXY(r_inner, b_inner, 'r^-3') p.addXY(r_outer, b_outer, 'r^-1.6') p.defaultKeyOverlay.vAlign = 0.9 p.setBounds(1, 200, 1, 2e6) p.setLabels('L or RJ', '|B| (nT)') return p
def main(): pg = om.makeDisplayPager() for ident, flitem, geojson in postprocess.get_events(): for ftnum, feature in enumerate( geojson['features'][0]['geometry']['coordinates']): x_orig = np.array([t[0] for t in feature]) y_orig = np.array([t[1] for t in feature]) area, x, y = postprocess.fix_polygon_handedness(x_orig, y_orig) if area < postprocess.AREA_CUTOFF_68: print('skipping %s+%d: A=%.1f' % (ident, ftnum + 1, area)) continue x, y = postprocess.smooth_polygon(x, y) p = om.quickXY(x_orig, y_orig, 'Original %s+%d: A=%.1f' % (ident, ftnum + 1, area)) p.addXY(x, y, 'Smoothed') pg.send(p) pg.done()
def l_plot(self, v, **kwargs): import omega as om return om.quickXY(self.l_sort(), self.l_sort(v), **kwargs)