def _write_gamma_detail(br, interaction, i, filename=None, verbose=True):
gamma_detail = br.get_gamma_detail_at_q()
temperatures = br.get_temperatures()
mesh = br.get_mesh_numbers()
grid_points = br.get_grid_points()
gp = grid_points[i]
sigmas = br.get_sigmas()
triplets, weights, _, _ = interaction.get_triplets_at_q()
for j, sigma in enumerate(sigmas):
write_gamma_detail_to_hdf5(gamma_detail, temperatures, mesh, gp, sigma,
triplets, weights)
def _write_gamma_detail(br,
interaction,
i,
compression=None,
filename=None,
verbose=True):
gamma_detail = br.get_gamma_detail_at_q()
temperatures = br.get_temperatures()
mesh = br.get_mesh_numbers()
grid_points = br.get_grid_points()
gp = grid_points[i]
sigmas = br.get_sigmas()
sigma_cutoff = br.get_sigma_cutoff_width()
triplets, weights, map_triplets, _ = interaction.get_triplets_at_q()
grid_address = interaction.get_grid_address()
bz_map = interaction.get_bz_map()
if map_triplets is None:
all_triplets = None
else:
all_triplets = get_all_triplets(gp, grid_address, bz_map, mesh)
if all_bands_exist(interaction):
for j, sigma in enumerate(sigmas):
write_gamma_detail_to_hdf5(temperatures,
mesh,
gamma_detail=gamma_detail,
grid_point=gp,
triplet=triplets,
weight=weights,
triplet_map=map_triplets,
triplet_all=all_triplets,
sigma=sigma,
sigma_cutoff=sigma_cutoff,
compression=compression,
filename=filename,
verbose=verbose)
else:
for j, sigma in enumerate(sigmas):
for k, bi in enumerate(interaction.get_band_indices()):
write_gamma_detail_to_hdf5(temperatures,
mesh,
gamma_detail=gamma_detail[:, :,
k, :, :],
grid_point=gp,
triplet=triplets,
weight=weights,
band_index=bi,
sigma=sigma,
sigma_cutoff=sigma_cutoff,
compression=compression,
filename=filename,
verbose=verbose)
def get_imag_self_energy(
interaction,
grid_points,
sigmas,
frequency_step=None,
num_frequency_points=None,
temperatures=None,
scattering_event_class=None, # class 1 or 2
write_detail=False,
output_filename=None,
log_level=0):
"""Imaginary part of self energy at frequency points
Band indices to be calculated at are kept in Interaction instance.
Args:
interaction: Ph-ph interaction
grid_points: Grid-point indices to be caclculated on
sigmas:
A set of sigmas. simga=None means to use tetrahedron method,
otherwise smearing method with real positive value of sigma.
frequency_step: Pitch of frequency to be sampled.
num_frequency_points: Number of sampling sampling points to be used
instead of frequency_step.
temperatures: Temperatures to be calculated at.
scattering_event_class:
Extract scattering event class 1 or 2.
log_level: Log level. 0 or non 0 in this method.
Returns:
Tuple: (Imaginary part of self energy, sampling frequency points)
"""
if temperatures is None:
temperatures = [0.0, 300.0]
if temperatures is None:
print("Temperatures have to be set.")
return False
mesh = interaction.get_mesh_numbers()
ise = ImagSelfEnergy(interaction, with_detail=write_detail)
imag_self_energy = []
frequency_points = []
for i, gp in enumerate(grid_points):
ise.set_grid_point(gp)
if log_level:
weights = interaction.get_triplets_at_q()[1]
print("------------------- Imaginary part of self energy (%d/%d) "
"-------------------" % (i + 1, len(grid_points)))
print("Grid point: %d" % gp)
print("Number of ir-triplets: "
"%d / %d" % (len(weights), weights.sum()))
ise.run_interaction()
frequencies = interaction.get_phonons()[0]
max_phonon_freq = np.amax(frequencies)
if log_level:
adrs = interaction.get_grid_address()[gp]
q = adrs.astype('double') / mesh
print("q-point: %s" % q)
print("Phonon frequency:")
text = "[ "
for i, freq in enumerate(frequencies[gp]):
if i % 6 == 0 and i != 0:
text += "\n"
text += "%8.4f " % freq
text += "]"
print(text)
sys.stdout.flush()
gamma_sigmas = []
fp_sigmas = []
if write_detail:
(triplets, weights, map_triplets,
_) = interaction.get_triplets_at_q()
for j, sigma in enumerate(sigmas):
if log_level:
if sigma:
print("Sigma: %s" % sigma)
else:
print("Tetrahedron method")
ise.set_sigma(sigma)
if sigma:
fmax = max_phonon_freq * 2 + sigma * 4
else:
fmax = max_phonon_freq * 2
fmax *= 1.005
fmin = 0
frequency_points_at_sigma = get_frequency_points(
fmin,
fmax,
frequency_step=frequency_step,
num_frequency_points=num_frequency_points)
fp_sigmas.append(frequency_points_at_sigma)
gamma = np.zeros(
(len(temperatures), len(frequency_points_at_sigma),
len(interaction.get_band_indices())),
dtype='double')
if write_detail:
num_band0 = len(interaction.get_band_indices())
num_band = frequencies.shape[1]
detailed_gamma = np.zeros(
(len(temperatures), len(frequency_points_at_sigma),
len(weights), num_band0, num_band, num_band),
dtype='double')
for k, freq_point in enumerate(frequency_points_at_sigma):
ise.set_frequency_points([freq_point])
ise.set_integration_weights(
scattering_event_class=scattering_event_class)
for l, t in enumerate(temperatures):
ise.set_temperature(t)
ise.run()
gamma[l, k] = ise.get_imag_self_energy()[0]
if write_detail:
detailed_gamma[l, k] = (
ise.get_detailed_imag_self_energy()[0])
gamma_sigmas.append(gamma)
if write_detail:
full_filename = write_gamma_detail_to_hdf5(
temperatures,
mesh,
gamma_detail=detailed_gamma,
grid_point=gp,
triplet=triplets,
weight=weights,
triplet_map=map_triplets,
sigma=sigma,
frequency_points=frequency_points_at_sigma,
filename=output_filename)
if log_level:
print("Contribution of each triplet to imaginary part of "
"self energy is written in\n\"%s\"." % full_filename)
imag_self_energy.append(gamma_sigmas)
frequency_points.append(fp_sigmas)
return imag_self_energy, frequency_points
def get_imag_self_energy(interaction,
grid_points,
temperatures,
sigmas=None,
frequency_points=None,
frequency_step=None,
num_frequency_points=None,
num_points_in_batch=None,
scattering_event_class=None, # class 1 or 2
write_gamma_detail=False,
return_gamma_detail=False,
output_filename=None,
log_level=0):
"""Imaginary part of self energy at frequency points
Band indices to be calculated at are kept in Interaction instance.
Parameters
----------
interaction : Interaction
Ph-ph interaction.
grid_points : array_like
Grid-point indices where imag-self-energeis are caclculated.
dtype=int, shape=(grid_points,)
temperatures : array_like
Temperatures where imag-self-energies are calculated.
dtype=float, shape=(temperatures,)
sigmas : array_like, optional
A set of sigmas. simgas=[None, ] means to use tetrahedron method,
otherwise smearing method with real positive value of sigma.
For example, sigmas=[None, 0.01, 0.03] is possible. Default is None,
which results in [None, ].
dtype=float, shape=(sigmas,)
frequency_points : array_like, optional
Frequency sampling points. Default is None. In this case,
num_frequency_points or frequency_step is used to generate uniform
frequency sampling points.
dtype=float, shape=(frequency_points,)
frequency_step : float, optional
Uniform pitch of frequency sampling points. Default is None. This
results in using num_frequency_points.
num_frequency_points: int, optional
Number of sampling sampling points to be used instead of
frequency_step. This number includes end points. Default is None,
which gives 201.
num_points_in_batch: int, optional
Number of sampling points in one batch. This is for the frequency
sampling mode and the sampling points are divided into batches.
Lager number provides efficient use of multi-cores but more
memory demanding. Default is None, which give the number of 10.
scattering_event_class : int, optional
Specific choice of scattering event class, 1 or 2 that is specified
1 or 2, respectively. The result is stored in gammas. Therefore
usual gammas are not stored in the variable. Default is None, which
doesn't specify scattering_event_class.
write_gamma_detail : bool, optional
Detailed gammas are written into a file in hdf5. Default is False.
return_gamma_detail : bool, optional
With True, detailed gammas are returned. Default is False.
log_level: int
Log level. Default is 0.
Returns
-------
tuple :
(frequency_points, gammas) are returned. With return_gamma_detail=True,
(frequency_points, gammas, detailed_gammas) are returned.
"""
if sigmas is None:
_sigmas = [None, ]
else:
_sigmas = sigmas
if (interaction.get_phonons()[2] == 0).any():
if log_level:
print("Running harmonic phonon calculations...")
interaction.run_phonon_solver()
mesh = interaction.mesh_numbers
frequencies = interaction.get_phonons()[0]
max_phonon_freq = np.amax(frequencies)
_frequency_points = get_frequency_points(
max_phonon_freq=max_phonon_freq,
sigmas=_sigmas,
frequency_points=frequency_points,
frequency_step=frequency_step,
num_frequency_points=num_frequency_points)
ise = ImagSelfEnergy(
interaction, with_detail=(write_gamma_detail or return_gamma_detail))
gamma = np.zeros(
(len(grid_points), len(_sigmas), len(temperatures),
len(interaction.band_indices), len(_frequency_points)),
dtype='double', order='C')
detailed_gamma = []
for i, gp in enumerate(grid_points):
ise.set_grid_point(gp)
if log_level:
weights = interaction.get_triplets_at_q()[1]
print("------------------- Imaginary part of self energy (%d/%d) "
"-------------------" % (i + 1, len(grid_points)))
print("Grid point: %d" % gp)
print("Number of ir-triplets: "
"%d / %d" % (len(weights), weights.sum()))
ise.run_interaction()
if log_level:
adrs = interaction.grid_address[gp]
q = adrs.astype('double') / mesh
print("q-point: %s" % q)
print("Phonon frequency:")
text = "[ "
for bi, freq in enumerate(frequencies[gp]):
if bi % 6 == 0 and bi != 0:
text += "\n"
text += "%8.4f " % freq
text += "]"
print(text)
sys.stdout.flush()
if write_gamma_detail or return_gamma_detail:
(triplets, weights,
map_triplets, _) = interaction.get_triplets_at_q()
num_band0 = len(interaction.band_indices)
num_band = frequencies.shape[1]
detailed_gamma_at_gp = np.zeros(
(len(_sigmas), len(temperatures), len(_frequency_points),
len(weights), num_band0, num_band, num_band),
dtype='double')
else:
detailed_gamma_at_gp = None
for j, sigma in enumerate(_sigmas):
if log_level:
if sigma:
print("Sigma: %s" % sigma)
else:
print("Tetrahedron method is used for BZ integration.")
ise.set_sigma(sigma)
# Run one by one at frequency points
if detailed_gamma_at_gp is None:
detailed_gamma_at_gp_at_j = None
else:
detailed_gamma_at_gp_at_j = detailed_gamma_at_gp[j]
run_ise_at_frequency_points_batch(
_frequency_points,
ise,
temperatures,
gamma[i, j],
write_gamma_detail=write_gamma_detail,
return_gamma_detail=return_gamma_detail,
detailed_gamma_at_gp=detailed_gamma_at_gp_at_j,
scattering_event_class=scattering_event_class,
nelems_in_batch=num_points_in_batch,
log_level=log_level)
if write_gamma_detail:
full_filename = write_gamma_detail_to_hdf5(
temperatures,
mesh,
gamma_detail=detailed_gamma_at_gp[j],
grid_point=gp,
triplet=triplets,
weight=weights,
triplet_map=map_triplets,
sigma=sigma,
frequency_points=_frequency_points,
filename=output_filename)
if log_level:
print("Contribution of each triplet to imaginary part of "
"self energy is written in\n\"%s\"." % full_filename)
if return_gamma_detail:
detailed_gamma.append(detailed_gamma_at_gp)
if return_gamma_detail:
return _frequency_points, gamma, detailed_gamma
else:
return _frequency_points, gamma
def get_linewidth(interaction,
grid_points,
sigmas,
temperatures=np.arange(0, 1001, 10, dtype='double'),
run_with_g=True,
write_detail=False,
log_level=0):
ise = ImagSelfEnergy(interaction, with_detail=write_detail)
band_indices = interaction.get_band_indices()
mesh = interaction.get_mesh_numbers()
gamma = np.zeros(
(len(grid_points), len(sigmas), len(temperatures), len(band_indices)),
dtype='double')
print("--------------------------------"
" Linewidth "
"---------------------------------")
for i, gp in enumerate(grid_points):
ise.set_grid_point(gp)
if log_level:
print("======================= Grid point %d (%d/%d) "
"=======================" % (gp, i + 1, len(grid_points)))
weights = interaction.get_triplets_at_q()[1]
print("Number of ir-triplets: "
"%d / %d" % (len(weights), weights.sum()))
print("Calculating ph-ph interaction...")
ise.run_interaction()
frequencies = interaction.get_phonons()[0]
if log_level:
adrs = interaction.get_grid_address()[gp]
q = adrs.astype('double') / mesh
print("q-point: %s" % q)
print("Phonon frequency:")
print("%s" % frequencies[gp])
if write_detail:
triplets, weights, _, _ = interaction.get_triplets_at_q()
for j, sigma in enumerate(sigmas):
if log_level:
text = "Calculating linewidths with "
if sigma is None:
text += "tetrahedron method"
else:
text += "sigma=%s" % sigma
print(text)
ise.set_sigma(sigma)
if sigma is None or run_with_g:
ise.set_integration_weights()
if write_detail:
num_band0 = len(interaction.get_band_indices())
num_band = frequencies.shape[1]
num_temp = len(temperatures)
num_triplets = len(weights)
detailed_gamma = np.zeros(
(num_temp, num_triplets, num_band0, num_band, num_band),
dtype='double')
for k, t in enumerate(temperatures):
ise.set_temperature(t)
ise.run()
gamma[i, j, k] = ise.get_imag_self_energy()
if write_detail:
detailed_gamma[k] = ise.get_detailed_imag_self_energy()
if write_detail:
filename = write_gamma_detail_to_hdf5(detailed_gamma,
temperatures, mesh, gp,
sigma, triplets, weights)
if log_level:
print("Contribution of each triplet to imaginary part of "
"self energy is written in\n\"%s\"." % filename)
return gamma
