def polarization(self,
fig=None,
ax1=None,
ms=10.,
fs=20.,
lims=None,
tag_pola=None,
ind=None):
'''
Plot sublattice polarization.
:param fig: Figure. Default value None. (used by the method spectrum).
:param ax1: Axis. Default value None. (used by the method spectrum).
:param ms: Positive Float. Default value 10. Markersize.
:param fs: Positive Float. Default value 20. Fontsize.
:param lims: List, lims[0] energy min, lims[1] energy max.
:param tag_pola: Binary char. Default value None. Tag of the sublattice.
:param ind: List. Default value None. List of indices. (used in the method spectrum).
:returns:
* **fig** -- Figure.
'''
if fig is None:
error_handling.sys(self.sys)
error_handling.empty_ndarray(self.sys.en, 'sys.get_eig')
error_handling.positive_real(ms, 'ms')
error_handling.positive_real(fs, 'fs')
error_handling.lims(lims)
fig, ax2 = plt.subplots()
ax2 = plt.gca()
if lims is None:
ax2.set_ylim([-0.1, 1.1])
ind = np.ones(self.sys.lat.sites, bool)
else:
ind = (self.sys.en > lims[0]) & (self.sys.en < lims[1])
ax2.set_ylim([lims[0] - 0.1, lims[1] + 0.1])
else:
ax2 = plt.twinx()
error_handling.empty_ndarray(self.sys.pola, 'sys.get_pola')
error_handling.tag(tag_pola, self.sys.lat.tags)
x = np.arange(self.sys.lat.sites)
i_tag = self.sys.lat.tags == tag_pola
ax2.plot(x[ind],
np.ravel(self.sys.pola[ind, i_tag]),
'or',
markersize=(4 * ms) // 5)
str_tag = tag_pola.decode('ascii')
ylabel = '$<' + str_tag.upper() + '|' + str_tag.upper() + '>$'
ax2.set_ylabel(ylabel, fontsize=fs, color='red')
ax2.set_ylim([-0.1, 1.1])
ax2.set_xlim(-0.5, x[ind][-1] + 0.5)
for tick in ax2.xaxis.get_major_ticks():
tick.label.set_fontsize(fs)
for label in ax2.get_yticklabels():
label.set_color('r')
return fig, ax2
def spectrum(self, ms=10, fs=20, lims=None,
tag_pola=None, ipr=None, peterman=None):
'''
Plot spectrum (eigenenergies real part (blue circles),
and sublattice polarization if *pola* not empty (red circles).
:param ms: Default value 10. Markersize.
:param fs: Default value 20. Fontsize.
:param lims: List, lims[0] energy min, lims[1] energy max.
:param tag_pola: Default value None. Binary char. Tag of the sublattice.
:param ipr: Default value None. If True plot the Inverse Partitipation Ration.
:param petermann: Default value None. If True plot the Petermann factor.
:returns:
* **fig** -- Figure.
'''
error_handling.empty_ndarray(self.sys.en, 'sys.get_eig')
error_handling.positive_real(ms, 'ms')
error_handling.positive_real(fs, 'fs')
error_handling.lims(lims)
fig, ax1 = plt.subplots()
ax1 = plt.gca()
x = np.arange(self.sys.lat.sites)
if lims is None:
en_max = np.max(self.sys.en.real)
ax1.set_ylim([-en_max-0.2, en_max+0.2])
ind = np.ones(self.sys.lat.sites, bool)
else:
ind = (self.sys.en > lims[0]) & (self.sys.en < lims[1])
ax1.set_ylim([lims[0]-0.1, lims[1]+0.1])
ax1.plot(x[ind], self.sys.en.real[ind], 'ob', markersize=ms)
ax1.set_title('Spectrum', fontsize=fs)
ax1.set_xlabel('$n$', fontsize=fs)
ax1.set_ylabel('$E_n$', fontsize=fs, color='blue')
for label in ax1.get_yticklabels():
label.set_color('b')
if tag_pola:
error_handling.tag(tag_pola, self.sys.lat.tags)
fig, ax2 = self.polarization(fig=fig, ax1=ax1, ms=ms, fs=fs, tag_pola=tag_pola, ind=ind)
elif ipr:
fig, ax2 = self.ipr(fig=fig, ax1=ax1, ms=ms, fs=fs, ind=ind)
elif peterman:
fig, ax2 = self.petermann(fig=fig, ax1=ax1, ms=ms, fs=fs, ind=ind)
for label in ax1.xaxis.get_majorticklabels():
label.set_fontsize(fs)
for label in ax1.yaxis.get_majorticklabels():
label.set_fontsize(fs)
xa = ax1.get_xaxis()
ax1.set_xlim([x[ind][0]-0.5, x[ind][-1]+0.5])
xa.set_major_locator(plt.MaxNLocator(integer=True))
fig.set_tight_layout(True)
plt.draw()
return fig
def get_intensity_pola_min(self, tag_pola):
'''
Get the state with smallest polarization on one sublattice.
:param tag_pola: Binary char. Sublattice tag.
:returns:
* **intensity** -- Intensity of max polarized state on *tag*.
'''
error_handling.empty_ndarray(self.rn, 'sys.get_eig(eigenvec=True)')
error_handling.tag(tag_pola, self.lat.tags)
i_tag = self.lat.tags == tag_pola
ind = np.argmin(self.pola[:, i_tag])
print('State with polarization: {:.5f}'.format(float(self.pola[ind, i_tag])))
return self.intensity[:, ind]
def get_intensity_pola_min(self, tag_pola):
'''
Get the state with smallest polarization on one sublattice.
:param tag_pola: Binary char. Sublattice tag.
:returns:
* **intensity** -- Intensity of max polarized state on *tag*.
'''
error_handling.empty_ndarray(self.rn, 'sys.get_eig(eigenvec=True)')
error_handling.tag(tag_pola, self.lat.tags)
i_tag = self.lat.tags == tag_pola
ind = np.argmin(self.pola[:, i_tag])
print('State with polarization: {:.5f}'.format(
float(self.pola[ind, i_tag])))
return self.intensity[:, ind]
def polarization(self, fig=None, ax1=None, ms=10., fs=20., lims=None,
tag_pola=None, ind=None):
'''
Plot sublattice polarization.
:param fig: Figure. Default value None. (used by the method spectrum).
:param ax1: Axis. Default value None. (used by the method spectrum).
:param ms: Positive Float. Default value 10. Markersize.
:param fs: Positive Float. Default value 20. Fontsize.
:param lims: List, lims[0] energy min, lims[1] energy max.
:param tag_pola: Binary char. Default value None. Tag of the sublattice.
:param ind: List. Default value None. List of indices. (used in the method spectrum).
:returns:
* **fig** -- Figure.
'''
if fig is None:
error_handling.sys(self.sys)
error_handling.empty_ndarray(self.sys.en, 'sys.get_eig')
error_handling.positive_real(ms, 'ms')
error_handling.positive_real(fs, 'fs')
error_handling.lims(lims)
fig, ax2 = plt.subplots()
ax2 = plt.gca()
if lims is None:
ax2.set_ylim([-0.1, 1.1])
ind = np.ones(self.sys.lat.sites, bool)
else:
ind = (self.sys.en > lims[0]) & (self.sys.en < lims[1])
ax2.set_ylim([lims[0]-0.1, lims[1]+0.1])
else:
ax2 = plt.twinx()
error_handling.empty_ndarray(self.sys.pola, 'sys.get_pola')
error_handling.tag(tag_pola, self.sys.lat.tags)
x = np.arange(self.sys.lat.sites)
i_tag = self.sys.lat.tags == tag_pola
ax2.plot(x[ind], np.ravel(self.sys.pola[ind, i_tag]), 'or', markersize=(4*ms)//5)
str_tag = tag_pola.decode('ascii')
ylabel = '$<' + str_tag.upper() + '|' + str_tag.upper() + '>$'
ax2.set_ylabel(ylabel, fontsize=fs, color='red')
ax2.set_ylim([-0.1, 1.1])
ax2.set_xlim(-0.5, x[ind][-1]+0.5)
for tick in ax2.xaxis.get_major_ticks():
tick.label.set_fontsize(fs)
for label in ax2.get_yticklabels():
label.set_color('r')
return fig, ax2
def set_hopping(self, list_hop, upper_part=True):
'''
Set lattice hoppings.
:param list_hop: List of Dictionaries.
Dictionary with keys ('n', 'ang', 'tag', 't') where:
* 'n' Positive integer, type of hoppings:
* 'n': 1 for nearest neighbours.
* 'n': 2 for next-nearest neighbours.
* 'n': 3 for next-next-nearest neighbours.
* etc...
* 'ang' value, float, angle, in deg, of the hoppings. (optional).
Hopping angles are given by the method *print_distances*.
* If :math:`ang \in[0, 180)`, fill the Hamiltonian upper part.
* If :math:`ang \in[-180, 0)`, fill the Hamiltonian lower part.
* 'tag' binary string of length 2 (optional).
Hopping tags.
* 't' Complex number.
Hopping value.
:param upper_part: Boolean. Default value True.
* True get hoppings with (:math:`i<j`) *i.e.* fill the Hamiltonian lower part.
* False get hoppings with (:math:`i>j`) *i.e.* fill the Hamiltonian upper part.
Example usage::
# fill upper part:
sys.set_hopping([{'n': 1, t: 1.}])
# fill lower part:
sys.set_hopping([{'n': 1, t: 1.}], upper_part=False)
# fill upper part: specifying the angles:
sys.set_hopping([{'n': 1, 'ang': 0., t: 1.}, {'n': 1, 'ang': 90, t: 2.}])
# fill lower part:
sys.set_hopping([{'n': 1, 'ang': -180., t: 1.}, {'n': 1, 'ang': -90, t: 2.}], upper_part=False)
# fill upper part: specifying the tags:
sys.set_hopping([{'n': 1, 'tag': b'ab', t: 1.}, {'n': 1, 'tag': b'ba', t: 2.}])
# fill lower part:
sys.set_hopping([{'n': 1, 'tag': b'ab', t: 1.}, {'n': 1, 'tag': b'ba', t: 2.}], upper_part=False)
# fill upper part: specifying the angles and tags:
sys.set_hopping([{'n': 1, 'ang': 0., 'tag': b'ab', t: 1.},
{'n': 1, 'ang': 0., 'tag': b'ba', t: 2.},
{'n': 1, 'ang': 90., 'tag': b'ab', t: 3.},
{'n': 1, 'ang': 90., 'tag': b'ba', t: 4.}])
# fill lower part:
sys.set_hopping([{'n': 1, 'ang': 0., 'tag': b'ab', t: 1.},
{'n': 1, 'ang': 0., 'tag': b'ba', t: 2.},
{'n': 1, 'ang': 90., 'tag': b'ab', t: 3.},
{'n': 1, 'ang': 90., 'tag': b'ba', t: 4.}]), upper_part=False)
.. note::
A Hermitian hopping matrix can be build-up only using
its upper part OR only using its lower part. The full matrix is then
automatic built by Hermitian conjugaison.
If both upper AND lower parts are used to build up the hopping matrix.
non Hermitian conjugaison is not performed *i.e.* non-Hermitian hopping matrix
can be built.
'''
error_handling.sites(self.lat.sites)
error_handling.boolean(upper_part, 'upper_part')
self.get_distances()
self.nmax = len(self.dist_uni) - 1
error_handling.set_hopping(list_hop, self.nmax)
list_n = np.unique([dic['n'] for dic in list_hop])
# fill, if needed self.store_hop
self.check_sites()
for n in list_n:
if n not in self.store_hop:
self.fill_store_hop(n)
# fill self.hop
for dic in list_hop:
if len(dic) == 2:
size = len(self.store_hop[dic['n']])
if upper_part:
mask = (self.hop['n'] == dic['n']) & (self.hop['i'] < self.hop['j'])
else:
mask = (self.hop['n'] == dic['n']) & (self.hop['i'] > self.hop['j'])
if np.sum(mask):
self.hop = self.hop[np.logical_not(mask)]
ind = np.ones(size, bool)
hop = self.set_given_hopping(dic['n'], size, dic, ind, upper_part=upper_part)
elif len(dic) == 3 and 'ang' in dic:
error_handling.angle(dic['ang'], np.unique(self.store_hop[dic['n']]['ang']), upper_part)
if dic['ang'] >= 0:
ang_store = dic['ang']
else:
ang_store = dic['ang'] + 180.
size = np.sum(np.isclose(ang_store, self.store_hop[dic['n']]['ang'], atol=ATOL))
mask = (self.hop['n'] == dic['n']) & np.isclose(self.hop['ang'], dic['ang'], atol=ATOL)
if np.sum(mask):
self.hop = self.hop[np.logical_not(mask)]
ind = np.isclose(ang_store, self.store_hop[dic['n']]['ang'], atol=ATOL)
error_handling.index(ind, dic)
hop = self.set_given_hopping(dic['n'], size, dic, ind, upper_part=upper_part)
elif len(dic) == 3 and 'tag' in dic:
if upper_part:
tag_store = dic['tag']
else:
tag_store = dic['tag'][::-1]
size = np.sum(self.store_hop[dic['n']]['tag'] == tag_store)
mask = (self.hop['n'] == dic['n']) & (self.hop['tag'] == dic['tag'])
if upper_part:
mask = self.hop['n'] == dic['n'] & (self.hop['tag'] == dic['tag']) & (self.hop['i'] < self.hop['j'])
else:
mask = self.hop['n'] == dic['n'] & (self.hop['tag'] == dic['tag']) & (self.hop['i'] > self.hop['j'])
if np.sum(mask):
self.hop = self.hop[np.logical_not(mask)]
ind = self.store_hop[dic['n']]['tag'] == tag_store
error_handling.index(ind, dic)
hop = self.set_given_hopping(dic['n'], size, dic, ind, upper_part=upper_part)
else:
error_handling.angle(dic['ang'], np.unique(self.store_hop[dic['n']]['ang']), upper_part=upper_part)
error_handling.tag(dic['tag'], np.unique(self.store_hop[dic['n']]['tag']))
if dic['ang'] >= 0:
ang_store = dic['ang']
else:
ang_store = dic['ang'] + 180.
if upper_part:
tag_store = dic['tag']
else:
tag_store = dic['tag'][::-1]
size = np.sum((self.store_hop[dic['n']]['tag'] == tag_store) &
(np.isclose(ang_store, self.store_hop[dic['n']]['ang'], atol=ATOL)))
bool1 = (self.hop['n'] == dic['n']) & (self.hop['tag'] == dic['tag'])
bool2 = np.isclose(self.hop['ang'], dic['ang'], atol=ATOL)
mask = bool1 & bool2
if np.sum(mask):
self.hop = self.hop[np.logical_not(mask)]
ind = ((self.store_hop[dic['n']]['tag'] == tag_store) &
(np.isclose(ang_store, self.store_hop[dic['n']]['ang'], atol=1)))
error_handling.index(ind, dic)
hop = self.set_given_hopping(dic['n'], size, dic, ind, upper_part=upper_part)
self.hop = np.concatenate([self.hop, hop])
def set_hopping(self, list_hop, upper_part=True):
'''
Set lattice hoppings.
:param list_hop: List of Dictionaries.
Dictionary with keys ('n', 'ang', 'tag', 't') where:
* 'n' Positive integer, type of hoppings:
* 'n': 1 for nearest neighbours.
* 'n': 2 for next-nearest neighbours.
* 'n': 3 for next-next-nearest neighbours.
* etc...
* 'ang' value, float, angle, in deg, of the hoppings. (optional).
Hopping angles are given by the method *print_distances*.
* If :math:`ang \in[0, 180)`, fill the Hamiltonian upper part.
* If :math:`ang \in[-180, 0)`, fill the Hamiltonian lower part.
* 'tag' binary string of length 2 (optional).
Hopping tags.
* 't' Complex number.
Hopping value.
:param upper_part: Boolean. Default value True.
* True get hoppings with (:math:`i<j`) *i.e.* fill the Hamiltonian lower part.
* False get hoppings with (:math:`i>j`) *i.e.* fill the Hamiltonian upper part.
Example usage::
# fill upper part:
sys.set_hopping([{'n': 1, t: 1.}])
# fill lower part:
sys.set_hopping([{'n': 1, t: 1.}], upper_part=False)
# fill upper part: specifying the angles:
sys.set_hopping([{'n': 1, 'ang': 0., t: 1.}, {'n': 1, 'ang': 90, t: 2.}])
# fill lower part:
sys.set_hopping([{'n': 1, 'ang': -180., t: 1.}, {'n': 1, 'ang': -90, t: 2.}], upper_part=False)
# fill upper part: specifying the tags:
sys.set_hopping([{'n': 1, 'tag': b'ab', t: 1.}, {'n': 1, 'tag': b'ba', t: 2.}])
# fill lower part:
sys.set_hopping([{'n': 1, 'tag': b'ab', t: 1.}, {'n': 1, 'tag': b'ba', t: 2.}], upper_part=False)
# fill upper part: specifying the angles and tags:
sys.set_hopping([{'n': 1, 'ang': 0., 'tag': b'ab', t: 1.},
{'n': 1, 'ang': 0., 'tag': b'ba', t: 2.},
{'n': 1, 'ang': 90., 'tag': b'ab', t: 3.},
{'n': 1, 'ang': 90., 'tag': b'ba', t: 4.}])
# fill lower part:
sys.set_hopping([{'n': 1, 'ang': 0., 'tag': b'ab', t: 1.},
{'n': 1, 'ang': 0., 'tag': b'ba', t: 2.},
{'n': 1, 'ang': 90., 'tag': b'ab', t: 3.},
{'n': 1, 'ang': 90., 'tag': b'ba', t: 4.}]), upper_part=False)
.. note::
A Hermitian hopping matrix can be build-up only using
its upper part OR only using its lower part. The full matrix is then
automatic built by Hermitian conjugaison.
If both upper AND lower parts are used to build up the hopping matrix.
non Hermitian conjugaison is not performed *i.e.* non-Hermitian hopping matrix
can be built.
'''
error_handling.sites(self.lat.sites)
error_handling.boolean(upper_part, 'upper_part')
self.get_distances()
self.nmax = len(self.dist_uni) - 1
error_handling.set_hopping(list_hop, self.nmax)
list_n = np.unique([dic['n'] for dic in list_hop])
# fill, if needed self.store_hop
self.check_sites()
for n in list_n:
if n not in self.store_hop:
self.fill_store_hop(n)
# fill self.hop
for dic in list_hop:
if len(dic) == 2:
size = len(self.store_hop[dic['n']])
if upper_part:
mask = (self.hop['n']
== dic['n']) & (self.hop['i'] < self.hop['j'])
else:
mask = (self.hop['n']
== dic['n']) & (self.hop['i'] > self.hop['j'])
if np.sum(mask):
self.hop = self.hop[np.logical_not(mask)]
ind = np.ones(size, bool)
hop = self.set_given_hopping(dic['n'],
size,
dic,
ind,
upper_part=upper_part)
elif len(dic) == 3 and 'ang' in dic:
error_handling.angle(
dic['ang'], np.unique(self.store_hop[dic['n']]['ang']),
upper_part)
if dic['ang'] >= 0:
ang_store = dic['ang']
else:
ang_store = dic['ang'] + 180.
size = np.sum(
np.isclose(ang_store,
self.store_hop[dic['n']]['ang'],
atol=ATOL))
mask = (self.hop['n'] == dic['n']) & np.isclose(
self.hop['ang'], dic['ang'], atol=ATOL)
if np.sum(mask):
self.hop = self.hop[np.logical_not(mask)]
ind = np.isclose(ang_store,
self.store_hop[dic['n']]['ang'],
atol=ATOL)
error_handling.index(ind, dic)
hop = self.set_given_hopping(dic['n'],
size,
dic,
ind,
upper_part=upper_part)
elif len(dic) == 3 and 'tag' in dic:
if upper_part:
tag_store = dic['tag']
else:
tag_store = dic['tag'][::-1]
size = np.sum(self.store_hop[dic['n']]['tag'] == tag_store)
mask = (self.hop['n'] == dic['n']) & (self.hop['tag']
== dic['tag'])
if upper_part:
mask = self.hop['n'] == dic['n'] & (
self.hop['tag']
== dic['tag']) & (self.hop['i'] < self.hop['j'])
else:
mask = self.hop['n'] == dic['n'] & (
self.hop['tag']
== dic['tag']) & (self.hop['i'] > self.hop['j'])
if np.sum(mask):
self.hop = self.hop[np.logical_not(mask)]
ind = self.store_hop[dic['n']]['tag'] == tag_store
error_handling.index(ind, dic)
hop = self.set_given_hopping(dic['n'],
size,
dic,
ind,
upper_part=upper_part)
else:
error_handling.angle(dic['ang'],
np.unique(
self.store_hop[dic['n']]['ang']),
upper_part=upper_part)
error_handling.tag(dic['tag'],
np.unique(self.store_hop[dic['n']]['tag']))
if dic['ang'] >= 0:
ang_store = dic['ang']
else:
ang_store = dic['ang'] + 180.
if upper_part:
tag_store = dic['tag']
else:
tag_store = dic['tag'][::-1]
size = np.sum((self.store_hop[dic['n']]['tag'] == tag_store)
& (np.isclose(ang_store,
self.store_hop[dic['n']]['ang'],
atol=ATOL)))
bool1 = (self.hop['n'] == dic['n']) & (self.hop['tag']
== dic['tag'])
bool2 = np.isclose(self.hop['ang'], dic['ang'], atol=ATOL)
mask = bool1 & bool2
if np.sum(mask):
self.hop = self.hop[np.logical_not(mask)]
ind = (
(self.store_hop[dic['n']]['tag'] == tag_store) &
(np.isclose(
ang_store, self.store_hop[dic['n']]['ang'], atol=1)))
error_handling.index(ind, dic)
hop = self.set_given_hopping(dic['n'],
size,
dic,
ind,
upper_part=upper_part)
self.hop = np.concatenate([self.hop, hop])
def spectrum(self,
ms=10,
fs=20,
lims=None,
tag_pola=None,
ipr=None,
peterman=None):
'''
Plot spectrum (eigenenergies real part (blue circles),
and sublattice polarization if *pola* not empty (red circles).
:param ms: Default value 10. Markersize.
:param fs: Default value 20. Fontsize.
:param lims: List, lims[0] energy min, lims[1] energy max.
:param tag_pola: Default value None. Binary char. Tag of the sublattice.
:param ipr: Default value None. If True plot the Inverse Partitipation Ration.
:param petermann: Default value None. If True plot the Petermann factor.
:returns:
* **fig** -- Figure.
'''
error_handling.empty_ndarray(self.sys.en, 'sys.get_eig')
error_handling.positive_real(ms, 'ms')
error_handling.positive_real(fs, 'fs')
error_handling.lims(lims)
fig, ax1 = plt.subplots()
ax1 = plt.gca()
x = np.arange(self.sys.lat.sites)
if lims is None:
en_max = np.max(self.sys.en.real)
ax1.set_ylim([-en_max - 0.2, en_max + 0.2])
ind = np.ones(self.sys.lat.sites, bool)
else:
ind = (self.sys.en > lims[0]) & (self.sys.en < lims[1])
ax1.set_ylim([lims[0] - 0.1, lims[1] + 0.1])
ax1.plot(x[ind], self.sys.en.real[ind], 'ob', markersize=ms)
ax1.set_title('Spectrum', fontsize=fs)
ax1.set_xlabel('$n$', fontsize=fs)
ax1.set_ylabel('$E_n$', fontsize=fs, color='blue')
for label in ax1.get_yticklabels():
label.set_color('b')
if tag_pola:
error_handling.tag(tag_pola, self.sys.lat.tags)
fig, ax2 = self.polarization(fig=fig,
ax1=ax1,
ms=ms,
fs=fs,
tag_pola=tag_pola,
ind=ind)
elif ipr:
fig, ax2 = self.ipr(fig=fig, ax1=ax1, ms=ms, fs=fs, ind=ind)
elif peterman:
fig, ax2 = self.petermann(fig=fig, ax1=ax1, ms=ms, fs=fs, ind=ind)
for label in ax1.xaxis.get_majorticklabels():
label.set_fontsize(fs)
for label in ax1.yaxis.get_majorticklabels():
label.set_fontsize(fs)
xa = ax1.get_xaxis()
ax1.set_xlim([x[ind][0] - 0.5, x[ind][-1] + 0.5])
xa.set_major_locator(plt.MaxNLocator(integer=True))
fig.set_tight_layout(True)
plt.draw()
return fig
