def create_rotator(self, bb):
if self.current_street == self.Preflop:
preflop_players = self.players[2:] + self.players[:2]
rotator = rotator_control.Rotator(preflop_players, bb, bb)
else:
rotator = rotator_control.Rotator(self.players, 0, bb)
return rotator
def projscatter(self, theta, phi=None, *args, **kwds):
"""Projscatter is a wrapper around :func:`matplotlib.Axes.scatter` to take into account the
spherical projection.
You can call this function as::
projscatter(theta, phi) # plot points at coord (theta, phi)
projplot(thetaphi) # plot points at coord (thetaphi[0], thetaphi[1])
Parameters
----------
theta, phi : float, array-like
Coordinates of point to plot. Can be put into one 2-d array, first line is
then *theta* and second line is *phi*. See *lonlat* parameter for unit.
lonlat : bool, optional
If True, theta and phi are interpreted as longitude and latitude
in degree, otherwise, as colatitude and longitude in radian
coord : {'E', 'G', 'C', None}, optional
The coordinate system of the points, only used if the coordinate
coordinate system of the axes has been defined and in this
case, a rotation is performed
rot : None or sequence, optional
rotation to be applied =(lon, lat, psi) : lon, lat will be position of the
new Z axis, and psi is rotation around this axis, all in degree.
if None, no rotation is performed
direct : bool, optional
if True, the rotation to center the projection is not
taken into account
Notes
-----
Other keywords are passed to :func:`matplotlib.Axes.plot`.
See Also
--------
projplot, projtext
"""
save_input_data = hasattr(self.figure, 'zoomtool')
if save_input_data:
input_data = (theta, phi, args, kwds.copy())
if phi is None:
theta, phi = np.asarray(theta)
else:
theta, phi = np.asarray(theta), np.asarray(phi)
rot = kwds.pop('rot', None)
if rot is not None:
rot = np.array(np.atleast_1d(rot), copy=1)
rot.resize(3)
rot[1] = rot[1] - 90.
coord = self.proj.mkcoord(kwds.pop('coord', None))[::-1]
lonlat = kwds.pop('lonlat', False)
vec = R.dir2vec(theta, phi, lonlat=lonlat)
vec = (R.Rotator(rot=rot, coord=coord, eulertype='Y')).I(vec)
x, y = self.proj.vec2xy(vec, direct=kwds.pop('direct', False))
s = self.scatter(x, y, *args, **kwds)
if save_input_data:
if not hasattr(self, '_scatter_data'):
self._scatter_data = []
self._scatter_data.append((s, input_data))
return s
def projtext(self, theta, phi, s, *args, **kwds):
"""Projtext is a wrapper around Axes.text to take into account the
spherical projection.
Modification of projtext vs text:
Three args allowed:
- theta, phi, text
Additional keywords :
- lonlat: if True, theta and phi are interpreted as longitude and latitude
in degree, otherwise, as theta, phi in radian
- coord: the coordinate system of the points, only used if the coordinate
coordinate system of the Axes has been defined and in this
case, a rotation is performed
- rot: rotation to be applied =(a,b,c) : a,b will be position of the
new Z axis, and c is rotation around this axis, all in degree.
if None, no rotation is performed
- direct: if True, the rotation to center the projection is not
taken into account
"""
if phi is None:
theta, phi = npy.asarray(theta)
else:
theta, phi = npy.asarray(theta), npy.asarray(phi)
rot = kwds.pop('rot', None)
if rot is not None:
rot = npy.array(npy.atleast_1d(rot), copy=1)
rot.resize(3)
rot[1] = rot[1] - 90.
coord = self.proj.mkcoord(kwds.pop('coord', None))[::-1]
lonlat = kwds.pop('lonlat', False)
vec = R.dir2vec(theta, phi, lonlat=lonlat)
vec = (R.Rotator(rot=rot, coord=coord, eulertype='Y')).I(vec)
x, y = self.proj.vec2xy(vec, direct=kwds.pop('direct', False))
return self.text(x, y, s, *args, **kwds)
def projtext(self, theta, phi, s, **kwds):
"""Projtext is a wrapper around :func:`matplotlib.Axes.text` to take into account the
spherical projection.
Parameters
----------
theta, phi : float, array-like
Coordinates of point to plot. Can be put into one 2-d array, first line is
then *theta* and second line is *phi*. See *lonlat* parameter for unit.
text : str
The text to be displayed.
lonlat : bool, optional
If True, theta and phi are interpreted as longitude and latitude
in degree, otherwise, as colatitude and longitude in radian
coord : {'E', 'G', 'C', None}, optional
The coordinate system of the points, only used if the coordinate
coordinate system of the axes has been defined and in this
case, a rotation is performed
rot : None or sequence, optional
rotation to be applied =(lon, lat, psi) : lon, lat will be position of the
new Z axis, and psi is rotation around this axis, all in degree.
if None, no rotation is performed
direct : bool, optional
if True, the rotation to center the projection is not
taken into account
Notes
-----
Other keywords are passed to :func:`matplotlib.Axes.text`.
See Also
--------
projplot, projscatter
"""
if phi is None:
theta, phi = npy.asarray(theta)
else:
theta, phi = npy.asarray(theta), npy.asarray(phi)
rot = kwds.pop('rot', None)
if rot is not None:
rot = npy.array(npy.atleast_1d(rot), copy=1)
rot.resize(3)
rot[1] = rot[1] - 90.
coord = self.proj.mkcoord(kwds.pop('coord', None))[::-1]
lonlat = kwds.pop('lonlat', False)
vec = R.dir2vec(theta, phi, lonlat=lonlat)
vec = (R.Rotator(rot=rot, coord=coord, eulertype='Y')).I(vec)
x, y = self.proj.vec2xy(vec, direct=kwds.pop('direct', False))
return self.text(x, y, s, **kwds)
def projscatter(self, theta, phi=None, *args, **kwds):
"""Projscatter is a wrapper around Axes.scatter to take into account the
spherical projection.
Modification of projscatter vs scatter:
One or two args allowed:
- if one arg: arg = [theta,phi]
- if two args: args[0]=theta,args[1]=phi
Additional keywords :
- lonlat: if True, theta and phi are interpreted as longitude and latitude
in degree, otherwise, as theta, phi in radian
- coord: the coordinate system of the points, only used if the coordinate
coordinate system of the Axes has been defined and in this
case, a rotation is performed
- rot: rotation to be applied =(a,b,c) : a,b will be position of the
new Z axis, and c is rotation around this axis, all in degree.
if None, no rotation is performed
- direct: if True, the rotation to center the projection is not
taken into account
"""
save_input_data = hasattr(self.figure, 'zoomtool')
if save_input_data:
input_data = (theta, phi, args, kwds.copy())
if phi is None:
theta, phi = npy.asarray(theta)
else:
theta, phi = npy.asarray(theta), npy.asarray(phi)
rot = kwds.pop('rot', None)
if rot is not None:
rot = npy.array(npy.atleast_1d(rot), copy=1)
rot.resize(3)
rot[1] = rot[1] - 90.
coord = self.proj.mkcoord(kwds.pop('coord', None))[::-1]
lonlat = kwds.pop('lonlat', False)
vec = R.dir2vec(theta, phi, lonlat=lonlat)
vec = (R.Rotator(rot=rot, coord=coord, eulertype='Y')).I(vec)
x, y = self.proj.vec2xy(vec, direct=kwds.pop('direct', False))
s = self.scatter(x, y, *args, **kwds)
if save_input_data:
if not hasattr(self, '_scatter_data'):
self._scatter_data = []
self._scatter_data.append((s, input_data))
return s
def projmap(self, map, vec2pix_func, rot=None, coord=None):
"""Create an array containing the projection of the map.
Input:
- vec2pix_func: a function taking theta,phi and returning pixel number
- map: an array containing the spherical map to project,
the pixelisation is described by vec2pix_func
Return:
- a 2D array with the projection of the map.
Note: the Projector must contain information on the array.
"""
x, y = self.ij2xy()
if np.__version__ >= '1.1':
matype = np.ma.core.MaskedArray
else:
matype = np.ma.array
if type(x) is matype and x.mask is not np.ma.nomask:
w = (x.mask == False)
else:
w = slice(None)
img = np.zeros(x.shape, np.float64) - np.inf
vec = self.xy2vec(np.asarray(x[w]), np.asarray(y[w]))
vec = (R.Rotator(rot=rot, coord=self.mkcoord(coord))).I(vec)
pix = vec2pix_func(vec[0], vec[1], vec[2])
# support masked array for map, or a dictionnary (for explicit pixelisation)
if isinstance(map, matype) and map.mask is not np.ma.nomask:
mpix = map[pix]
mpix[map.mask[pix]] = UNSEEN
elif isinstance(map, dict):
is_pix_seen = np.in1d(pix, map.keys()).reshape(pix.shape)
is_pix_unseen = ~is_pix_seen
mpix = np.zeros_like(img[w])
mpix[is_pix_unseen] = UNSEEN
pix_seen = pix[is_pix_seen]
iterable = (map[p] for p in pix_seen)
mpix[is_pix_seen] = np.fromiter(iterable,
mpix.dtype,
count=pix_seen.size)
else:
mpix = map[pix]
img[w] = mpix
return img
def graticule(self,
dpar=None,
dmer=None,
coord=None,
local=None,
verbose=True,
**kwds):
"""Draw a graticule.
Input:
- dpar: angular separation between parallels in degree
- dmer: angular separation between meridians in degree
- coord: coordinate system of the graticule ('G', 'E' or 'C')
- local: if True, no rotation performed at all
"""
gratargs = (dpar, dmer, coord, local)
gratkwds = kwds
if dpar is None: dpar = self._gratdef['dpar']
if local is None: local = self._gratdef['local']
if dmer is None: dmer = dpar
dpar = abs(dpar) * dtor
dmer = abs(dmer) * dtor
if not local:
vec = R.dir2vec(self.proj.get_center())
vec0 = R.Rotator(coord=self.proj.mkcoord(coord=coord)).I(vec)
else:
vec = (1, 0, 0)
vec0 = (1, 0, 0)
u_pmin, u_pmax = kwds.pop('pmax', None), kwds.pop('pmin', None)
u_mmin, u_mmax = kwds.pop('mmin', None), kwds.pop('mmax', None)
if u_pmin: u_pmin = (pi / 2. - u_pmin * dtor) % pi
if u_pmax: u_pmax = (pi / 2. - u_pmax * dtor) % pi
if u_mmin: u_mmin = (((u_mmin + 180.) % 360) - 180) * dtor
if u_mmax: u_mmax = (((u_mmax + 180.) % 360) - 180) * dtor
pmin, pmax = self.get_parallel_interval(vec0)
mmin, mmax = self.get_meridian_interval(vec0)
if u_pmin: pmin = u_pmin
if u_pmax: pmax = u_pmax
if u_mmin: mmin = u_mmin
if u_mmax: mmax = u_pmax
if verbose: print pmin / dtor, pmax / dtor, mmin / dtor, mmax / dtor
if not kwds.pop('force', False):
dpar, dmer = self._get_interv_graticule(pmin,
pmax,
dpar,
mmin,
mmax,
dmer,
verbose=verbose)
theta_list = np.around(
np.arange(pmin, pmax + 0.5 * dpar, dpar) / dpar) * dpar
phi_list = np.around(
np.arange(mmin, mmax + 0.5 * dmer, dmer) / dmer) * dmer
theta = np.arange(pmin, pmax,
min((pmax - pmin) / 100., self._segment_step_rad))
phi = np.arange(mmin, mmax,
min((mmax - mmin) / 100., self._segment_step_rad))
equator = False
gratlines = []
kwds.setdefault('lw', 1)
kwds.setdefault('color', 'k')
for t in theta_list:
if abs(t - pi / 2.) < 1.e-10:
fmt = '-'
equator = True
elif abs(t) < 1.e-10: # special case: north pole
t = 1.e-10
fmt = '-'
elif abs(t - pi) < 1.e-10: # special case: south pole
t = pi - 1.e-10
fmt = '-'
else:
fmt = ':'
gratlines.append(
self.projplot(phi * 0. + t,
phi,
fmt,
coord=coord,
direct=local,
**kwds))
if not equator and pmin <= pi / 2. and pi / 2 <= pmax:
gratlines.append(
self.projplot(phi * 0. + pi / 2.,
phi,
'-',
coord=coord,
direct=local,
**kwds))
for p in phi_list:
if abs(p) < 1.e-10: fmt = '-'
else: fmt = ':'
gratlines.append(
self.projplot(theta,
theta * 0. + p,
fmt,
coord=coord,
direct=local,
**kwds))
# Now the borders (only useful for full sky projection)
if hasattr(self, '_do_border') and self._do_border:
theta = np.arange(0, 181) * dtor
gratlines.append(
self.projplot(theta, theta * 0 - pi, '-k', lw=1, direct=True))
gratlines.append(
self.projplot(theta,
theta * 0 + 0.9999 * pi,
'-k',
lw=1,
direct=True))
phi = np.arange(-180, 180) * dtor
gratlines.append(
self.projplot(phi * 0 + 1.e-10, phi, '-k', lw=1, direct=True))
gratlines.append(
self.projplot(phi * 0 + pi - 1.e-10,
phi,
'-k',
lw=1,
direct=True))
if hasattr(self, '_graticules'):
self._graticules.append((gratargs, gratkwds, gratlines))
else:
self._graticules = [(gratargs, gratkwds, gratlines)]
return dpar, dmer
def projplot(self, *args, **kwds):
"""projplot is a wrapper around :func:`matplotlib.Axes.plot` to take into account the
spherical projection.
You can call this function as::
projplot(theta, phi) # plot a line going through points at coord (theta, phi)
projplot(theta, phi, 'bo') # plot 'o' in blue at coord (theta, phi)
projplot(thetaphi) # plot a line going through points at coord (thetaphi[0], thetaphi[1])
projplot(thetaphi, 'bx') # idem but with blue 'x'
Parameters
----------
theta, phi : float, array-like
Coordinates of point to plot. Can be put into one 2-d array, first line is
then *theta* and second line is *phi*. See *lonlat* parameter for unit.
fmt : str
A format string (see :func:`matplotlib.Axes.plot` for details)
lonlat : bool, optional
If True, theta and phi are interpreted as longitude and latitude
in degree, otherwise, as colatitude and longitude in radian
coord : {'E', 'G', 'C', None}
The coordinate system of the points, only used if the coordinate
coordinate system of the Axes has been defined and in this
case, a rotation is performed
rot : None or sequence
rotation to be applied =(lon, lat, psi) : lon, lat will be position of the
new Z axis, and psi is rotation around this axis, all in degree.
if None, no rotation is performed
direct : bool
if True, the rotation to center the projection is not
taken into account
Notes
-----
Other keywords are passed to :func:`matplotlib.Axes.plot`.
See Also
--------
projscatter, projtext
"""
fmt = None
if len(args) < 1:
raise ValueError("No argument given")
if len(args) == 1:
theta, phi = np.asarray(args[0])
elif len(args) == 2:
if type(args[1]) is str:
fmt = args[1]
theta, phi = np.asarray(args[0])
else:
theta, phi = np.asarray(args[0]), np.asarray(args[1])
elif len(args) == 3:
if type(args[2]) is not str:
raise TypeError("Third argument must be a string")
else:
theta, phi = np.asarray(args[0]), np.asarray(args[1])
fmt = args[2]
else:
raise TypeError("Three args maximum")
rot = kwds.pop('rot', None)
if rot is not None:
rot = np.array(np.atleast_1d(rot), copy=1)
rot.resize(3)
rot[1] = rot[1] - 90.
coord = self.proj.mkcoord(kwds.pop('coord', None))[::-1]
lonlat = kwds.pop('lonlat', False)
vec = R.dir2vec(theta, phi, lonlat=lonlat)
vec = (R.Rotator(rot=rot, coord=coord, eulertype='Y')).I(vec)
x, y = self.proj.vec2xy(vec, direct=kwds.pop('direct', False))
x, y = self._make_segment(x,
y,
threshold=kwds.pop('threshold',
self._segment_threshold))
thelines = []
for xx, yy in zip(x, y):
if fmt is not None:
linestyle, marker, color = axes._process_plot_format(fmt)
kwds.setdefault('linestyle', linestyle)
kwds.setdefault('marker', marker)
if color is not None: kwds.setdefault('color', color)
l = lines.Line2D(xx, yy, **kwds)
self.add_line(l)
thelines.append(l)
return thelines
def projplot(self, *args, **kwds):
"""projplot is a wrapper around Axes.plot to take into account the
spherical projection.
Modification of projplot vs plot:
One, two or three args allowed:
- if one arg: theta,phi = args[0][0],args[0][1]
- if two : either theta,phi or [theta,phi],fmt
- if three: theta,phi,fmt
with fmt the format string.
Additional keywords :
- lonlat: if True, theta and phi are interpreted as longitude and latitude
in degree, otherwise, as theta, phi in radian
- coord: the coordinate system of the points, only used if the coordinate
coordinate system of the Axes has been defined and in this
case, a rotation is performed
- rot: rotation to be applied =(a,b,c) : a,b will be position of the
new Z axis, and c is rotation around this axis, all in degree.
if None, no rotation is performed
- direct: if True, the rotation to center the projection is not
taken into account
"""
fmt = None
if len(args) < 1:
raise ValueError("No argument given")
if len(args) == 1:
theta, phi = npy.asarray(args[0])
elif len(args) == 2:
if type(args[1]) is str:
fmt = args[1]
theta, phi = npy.asarray(args[0])
else:
theta, phi = npy.asarray(args[0]), npy.asarray(args[1])
elif len(args) == 3:
if type(args[2]) is not str:
raise TypeError("Third argument must be a string")
else:
theta, phi = npy.asarray(args[0]), npy.asarray(args[1])
fmt = args[2]
else:
raise TypeError("Three args maximum")
rot = kwds.pop('rot', None)
if rot is not None:
rot = npy.array(npy.atleast_1d(rot), copy=1)
rot.resize(3)
rot[1] = rot[1] - 90.
coord = self.proj.mkcoord(kwds.pop('coord', None))[::-1]
lonlat = kwds.pop('lonlat', False)
vec = R.dir2vec(theta, phi, lonlat=lonlat)
vec = (R.Rotator(rot=rot, coord=coord, eulertype='Y')).I(vec)
x, y = self.proj.vec2xy(vec, direct=kwds.pop('direct', False))
x, y = self._make_segment(x,
y,
threshold=kwds.pop('threshold',
self._segment_threshold))
thelines = []
for xx, yy in zip(x, y):
if fmt is not None:
linestyle, marker, color = axes._process_plot_format(fmt)
kwds.setdefault('linestyle', linestyle)
kwds.setdefault('marker', marker)
if color is not None: kwds.setdefault('color', color)
l = lines.Line2D(xx, yy, **kwds)
self.add_line(l)
thelines.append(l)
return thelines
import tensor_operators, generator, rotator
"""
context -> window -> scene -> collection -> objects -> meshes
"""
# variables
spins = [5, 1, 1] # spin rows per axis (x,y,z)
er = 3 # electron radius
dbs = 6 # distance between spins
# classes
gen = generator.Generator(spins, er, dbs)
gen.ClearScene()
gen.Create3DSpinsArray()
rot = rotator.Rotator(spins)
op = tensor_operators.TensorOperators(spins)
# scene set-up
arrows = bpy.data.collections["Spin Arrows"].objects
op.Paramagnetism()
rot.SpinsRotator(op.spins_tensor, "z", 0)
for arrow in arrows:
arrow.keyframe_insert(data_path="rotation_euler", frame=10)
arrow.active_material.node_tree.nodes["Principled BSDF"].inputs[
0].keyframe_insert(data_path="default_value", frame=10)
op.Ferromagnetism(np.pi)
rot.SpinsRotator(op.spins_tensor, "z", 0)
def __init__(self, spins):
self.arrows = collections["Spin Arrows"].objects
self.rot = rotator.Rotator(spins)
self.arrows = bpy.data.collections["Spin Arrows"].objects
def __init__(self, rot=None, coord=None, flipconv=None, **kwds):
self.rotator = R.Rotator(rot=rot, coord=None, eulertype='ZYX')
self.coordsys = R.Rotator(coord=coord).coordout
self.coordsysstr = R.Rotator(coord=coord).coordoutstr
self.set_flip(flipconv)
self.set_proj_plane_info(**kwds)