def poynting_streamplot(carr,
k,
ax=None,
figsize=None,
title=None,
set_limits=True,
mask=None,
support=None,
settings=None,
dxdy=None,
**kwargs):
import matplotlib.pyplot as plt
import numpy as np
import expresso.pycas as pc
from .phase_gradient import phase_gradient
e = get_unitless_bounds(carr)
xprefix, xfactor = get_metric_prefix(e[1][:2])
yprefix, yfactor = get_metric_prefix(e[0][:2])
extent = [
float(e[1][0]) / xfactor,
float(e[1][1]) / xfactor,
float(e[0][0]) / yfactor,
float(e[0][1]) / yfactor
]
x = np.linspace(extent[0], extent[1], carr.shape[1])
y = np.linspace(extent[2], extent[3], carr.shape[0])
if dxdy is None:
gx, gy = [g.data for g in phase_gradient(carr)]
gx /= xfactor * (x[0] - x[1])
gy /= yfactor * (y[0] - y[1])
gx += float(carr.evaluate(k * e[1][2]))
else:
gx, gy = dxdy
gx *= yfactor / xfactor
if support is not None:
if mask is not None:
raise ValueError('provide either support or mask arguments')
if isinstance(support, pc.Expression):
mask = pc.Not(support)
else:
mask = support.copy()
mask.data = np.logical_not(support.data)
if mask is not None:
import expresso.pycas
if isinstance(mask, pc.Expression):
if settings == None:
raise ValueError('no settings argument provided')
mask = expression_for_array(mask, carr, settings)
gx = np.ma.array(gx, mask=mask.data)
gy = np.ma.array(gy, mask=mask.data)
fig = None
if ax == None:
fig, ax = plt.subplots(figsize=figsize)
if title:
ax.set_title(title)
stream = ax.streamplot(x, y, gx, gy, **kwargs)
if set_limits:
ax.set_xlim(extent[0], extent[1])
ax.set_ylim(extent[2], extent[3])
from expresso.pycas import latex as rlatex
latex = lambda x: rlatex(x).replace(r'\text', r'\mathrm')
ax.set_ylabel("$%s$ [$%s %s$]" %
(latex(carr.axis[0]), yprefix, latex(e[0][2])))
ax.set_xlabel("$%s$ [$%s %s$]" %
(latex(carr.axis[1]), xprefix, latex(e[1][2])))
if fig:
plt.show()
return stream
def poynting_streamplot_with_start_points(carr,
k,
start_points,
color='w',
ax=None,
figsize=None,
title=None,
arrowsize=5,
arrowpositions=[0.1, 0.9],
set_limits=True,
mask=None,
support=None,
settings=None,
dxdy=None,
**kwargs):
import matplotlib.pyplot as plt
import numpy as np
import expresso.pycas as pc
from pypropagate.phase_gradient import phase_gradient
def streamlines(x, y, U, V, start_points):
import scipy as sci
import scipy.integrate
import scipy.interpolate
import numpy as np
N = len(start_points)
flat_start_values = np.array(start_points).flatten()
dt = np.sqrt((x[1] - x[0])**2 + (y[1] - y[0])**2)
NT = max(len(x), len(y))
norm = np.sqrt(U**2 + V**2) * dt
XY = (y, x)
uinterp = sci.interpolate.RegularGridInterpolator(XY,
U / norm,
fill_value=0,
bounds_error=False)
vinterp = sci.interpolate.RegularGridInterpolator(XY,
V / norm,
fill_value=0,
bounds_error=False)
dx = [0]
def interpolated_velocity(t, x):
x = x.reshape((N, 2))
res = np.stack([vinterp(x), uinterp(x)]).transpose().flatten()
dx[0] = res
return res
integrator = sci.integrate.ode(interpolated_velocity).set_integrator(
'dopri5')
integrator.set_initial_value(flat_start_values, 0)
integrated = np.zeros((NT, N, 2), dtype=float)
integrated[0] = start_points
for i in range(1, NT):
if not integrator.successful():
print "error"
break
integrated[i] = integrator.integrate(i * dt).reshape((N, 2))
if np.all(dx[0] == 0):
integrated = integrated[:i + 1]
break
return integrated
e = get_unitless_bounds(carr)
xprefix, xfactor = get_metric_prefix(e[1][:2])
yprefix, yfactor = get_metric_prefix(e[0][:2])
extent = [
float(e[1][0]) / xfactor,
float(e[1][1]) / xfactor,
float(e[0][0]) / yfactor,
float(e[0][1]) / yfactor
]
x = np.linspace(extent[0], extent[1], carr.shape[1])
y = np.linspace(extent[2], extent[3], carr.shape[0])
if dxdy is None:
gx, gy = phase_gradient(carr)
gx /= xfactor * (x[0] - x[1])
gy /= yfactor * (y[0] - y[1])
gx += float(carr.evaluate(k * e[1][2]))
else:
gx, gy = dxdy
gx *= yfactor / xfactor
if support is not None:
if mask is not None:
raise ValueError('provide either support or mask arguments')
if isinstance(support, pc.Expression):
mask = pc.Not(support)
else:
mask = support.copy()
mask.data = np.logical_not(support.data)
if mask is not None:
import expresso.pycas
if isinstance(mask, pc.Expression):
if settings == None:
raise ValueError('no settings argument provided')
mask = expression_for_array(mask, carr, settings)
gx = np.ma.array(gx.data, mask=mask.data)
gy = np.ma.array(gy.data, mask=mask.data)
fig = None
if ax == None:
fig, ax = plt.subplots(figsize=figsize)
if title:
ax.set_title(title)
start_points = [[
float(carr.evaluate(sp[1] / (yfactor * e[0][2]))),
float(carr.evaluate(sp[0] / (xfactor * e[1][2])))
] for sp in start_points]
stream = streamlines(x, y, gx.data, gy.data, start_points)
for i in range(stream.shape[1]):
ax.plot(stream[:, i, 1], stream[:, i, 0], '-', color=color, **kwargs)
import scipy
xmin, xmax = stream[:, i, 1].min(), stream[:, i, 1].max()
dx = (xmax - xmin) / len(stream[:, i, 1]) / 10
xpositions = [xmin + ap * (xmax - xmin) for ap in arrowpositions]
ypositions = scipy.interp(xpositions + [xp - dx for xp in xpositions],
stream[:, i, 1], stream[:, i, 0])
for i in range(len(arrowpositions)):
size = arrowsize
x0, y0, y1 = xpositions[i], ypositions[i], ypositions[
i + len(arrowpositions)]
props = dict(color=color,
width=0,
headwidth=size,
headlength=2 * size,
linewidth=0)
ax.annotate("",
xy=(x0, y0),
xycoords='data',
xytext=(x0 - dx, y1),
textcoords='data',
arrowprops=props)
if set_limits:
ax.set_xlim(extent[0], extent[1])
ax.set_ylim(extent[2], extent[3])
from expresso.pycas import latex as rlatex
latex = lambda x: rlatex(x).replace(r'\text', r'\mathrm')
ax.set_ylabel("$%s$ [$%s %s$]" %
(latex(carr.axis[0]), yprefix, latex(e[0][2])))
ax.set_xlabel("$%s$ [$%s %s$]" %
(latex(carr.axis[1]), xprefix, latex(e[1][2])))
if fig:
plt.show()
return stream
def is_uneven(x):
return pc.And(issubtype(x, pc.Types.Integer), pc.Not(is_even(x)))
return
m[s.z] = True
logic_evaluator.add_rule(is_function(s.x, s.y), s.z, comp_function_evaluator)
def is_atomic_evaluator(m):
if not m[s.x].is_atomic:
m[s.y] = False
return
m[s.y] = True
logic_evaluator.add_rule(is_atomic(s.x), s.y, is_atomic_evaluator)
logic_evaluator.add_rule(is_function(s.x), pc.Not(is_atomic(s.x)))
def is_symbol_evaluator(m):
if not m[s.x].is_symbol:
m[s.y] = False
return
m[s.y] = True
logic_evaluator.add_rule(is_symbol(s.x), s.y, is_symbol_evaluator)
def is_pure_numeric_evaluator(m):
m[s.y] = pc.And(*[is_pure_numeric(arg) for arg in m[s.x].args])
canonical_form.add_rule(1 / s.x, s.x**-1)
canonical_form.add_rule(pc.exp(s.x), pc.e**s.x)
canonical_form.add_rule(s.x**s.y,
s.z,
normalize_exponentiation,
condition=pc.equal(
pc.DominantType(pc.Type(s.y), pc.Types.Real),
pc.Types.Real))
canonical_form.add_rule(pc.exp(s.x), pc.e**s.x)
canonical_form.add_rule(pc.sqrt(s.x), s.x**(1 / pc.S(2)))
canonical_form.add_rule(s.x > s.y, s.y < s.x)
canonical_form.add_rule(s.x >= s.y, s.y <= s.x)
canonical_form.add_rule(s.x <= s.y, pc.Or(s.x < s.y, pc.equal(s.x, s.y)))
canonical_form.add_rule(pc.unequal(s.x, s.y), pc.Not(pc.equal(s.x, s.y)))
canonical_form.add_rule(abs(s.x),
pc.Max(s.x, -s.x),
condition=pc.equal(
pc.DominantType(pc.Type(s.x), pc.Types.Real),
pc.Types.Real))
canonical_form.add_rule(pc.Max(s.a, s.b), -pc.Min(-s.a, -s.b))
canonical_form.add_rule(pc.tan(s.x), pc.sin(s.x) / pc.cos(s.x))
canonical_form.add_rule(pc.cot(s.x), pc.cos(s.x) / pc.sin(s.x))
#canonical_form.add_rule(abs(s.x)<s.y,pc.And(s.x<s.y,-s.x<s.y),condition=pc.And(s.y>0,pc.equal(pc.DominantType(pc.Type(s.x),pc.Types.Real),pc.Types.Real)))
from .type_evaluator import issubtype
factor_evaluator.add_rule(s.x**s.a * s.y**s.a, (s.x * s.y)**s.a,
condition=pc.Or(s.x > 0, s.y > 0,
issubtype(s.a, pc.Types.Integer)))
factor_evaluator.add_rule(s.x**s.a * s.y**-s.a, (s.x / s.y)**s.a,
condition=pc.Or(s.x > 0, s.y > 0,
issubtype(s.a, pc.Types.Integer)))
factor_evaluator.add_rule(s.x**s.n * s.x, s.x**(s.n + 1))
factor_evaluator.add_rule(s.x**s.n * s.x**s.m, s.x**(s.n + s.m))
from .logic_evaluator import is_explicit_natural
evaluator.add_rule(s.a**s.x * s.b**s.x, (s.a * s.b)**(s.x),
condition=pc.And(
pc.Not(
pc.Or(is_explicit_natural(s.a),
is_explicit_natural(s.b))),
pc.Or(issubtype(s.x, pc.Types.Natural), s.a > 0,
s.b > 0)))
evaluator.add_rule(-(s.x + s.y), -s.x - s.y)
evaluator.add_rule(s.x * -1, -s.x)
evaluator.add_rule(-(-s.x), s.x)
evaluator.add_rule((-s.x) * s.y, -(s.x * s.y))
evaluator.add_rule(1 / -s.x, -(1 / s.x))
evaluator.add_rule(-pc.S(0), 0)
def extract_intersection(m):
pc.Types.Imaginary)
evaluator.add_rule(pc.OperationType(pc.Types.Imaginary * pc.Types.Imaginary),
pc.Types.Real)
evaluator.add_rule(pc.OperationType(s.x**pc.Types.Natural), s.x)
evaluator.add_rule(pc.OperationType(s.x**pc.Types.Integer),
pc.DominantType(s.x, pc.Types.Rational))
evaluator.add_rule(pc.OperationType(pc.Types.Natural**pc.Types.Rational),
pc.Types.Real)
evaluator.add_rule(pc.OperationType(s.x**s.y), pc.Types.Complex)
evaluator.add_rule(pc.OperationType(s.x * s.y),
pc.DominantType(s.x, s.y),
condition=pc.Not(
pc.Or(is_function_type(s.x, pc.Type),
is_function_type(s.y, pc.Type))))
evaluator.add_rule(pc.OperationType(s.x)**s.y,
pc.DominantType(s.x, s.y),
condition=pc.Not(
pc.Or(is_function_type(s.x, pc.Type),
is_function_type(s.y, pc.Type))))
evaluator.add_rule(pc.Type(s.x + s.y),
pc.DominantType(pc.Type(s.x), pc.Type(s.y)))
evaluator.add_rule(pc.Type(-s.x),
pc.DominantType(pc.Types.Integer, pc.Type(s.x)))
evaluator.add_rule(pc.Type(pc.pi), pc.Types.Real)
evaluator.add_rule(pc.Type(pc.e), pc.Types.Real)
evaluator.add_rule(pc.Type(pc.I), pc.Types.Imaginary)
