def write_kappa(self, filename):
temperatures = self.get_temperatures()
for i, sigma in enumerate(self._sigmas):
kappa = self._kappa[i]
write_kappa_to_hdf5(self._gamma[i],
temperatures,
self.get_mesh_numbers(),
frequency=self.get_frequencies(),
group_velocity=self.get_group_velocities(),
heat_capacity=self.get_mode_heat_capacities(),
kappa=kappa,
qpoint=self.get_qpoints(),
weight=self.get_grid_weights(),
mesh_divisors=self.get_mesh_divisors(),
sigma=sigma,
filename=filename,
gnu=(self._gamma_N[i],self._gamma_U[i]))
if self._write_tecplot:
for j,temp in enumerate(temperatures):
write_kappa_to_tecplot_BZ(np.where(self._gamma[i,:,j]>1e-8, self._gamma[i,:,j],0),
temp,
self.get_mesh_numbers(),
bz_q_address=self._bz_grid_address / self.get_mesh_numbers().astype(float),
tetrahedrdons=self._unique_vertices,
bz_to_pp_mapping=self._bz_to_pp_map,
rec_lattice=np.linalg.inv(self._primitive.get_cell()),
spg_indices_mapping=self._irr_index_mapping,
spg_rotation_mapping=self._rot_mappings,
frequency=self.get_frequencies(),
group_velocity=self.get_group_velocities(),
heat_capacity=self.get_mode_heat_capacities()[:,j],
kappa=kappa[:,j],
weight=self.get_grid_weights(),
sigma=sigma,
filename=filename+"-bz")
def _write_kappa(br, filename=None, log_level=0):
temperatures = br.get_temperatures()
sigmas = br.get_sigmas()
gamma = br.get_gamma()
gamma_isotope = br.get_gamma_isotope()
mesh = br.get_mesh_numbers()
mesh_divisors = br.get_mesh_divisors()
frequencies = br.get_frequencies()
gv = br.get_group_velocities()
mode_cv = br.get_mode_heat_capacities()
ave_pp = br.get_averaged_pp_interaction()
qpoints = br.get_qpoints()
weights = br.get_grid_weights()
kappa = br.get_kappa()
mode_kappa = br.get_mode_kappa()
num_ignored_phonon_modes = br.get_number_of_ignored_phonon_modes()
num_band = br.get_frequencies().shape[1]
num_phonon_modes = br.get_number_of_sampling_grid_points() * num_band
for i, sigma in enumerate(sigmas):
kappa_at_sigma = kappa[i]
if gamma_isotope is not None:
gamma_isotope_at_sigma = gamma_isotope[i]
else:
gamma_isotope_at_sigma = None
if log_level:
print "----------- Thermal conductivity (W/m-k)",
if sigma:
print "for sigma=%s -----------" % sigma
else:
print "with tetrahedron method -----------"
if log_level > 1:
print("#%6s " + " %-9s" * 6 +
"#ipm") % ("T(K)", "xx", "yy", "zz", "yz", "xz", "xy")
for j, (t, k) in enumerate(zip(temperatures, kappa_at_sigma)):
print("%7.1f" + " %9.3f" * 6 + " %d/%d") % (
(t, ) + tuple(k) +
(num_ignored_phonon_modes[i, j], num_phonon_modes))
else:
print("#%6s " + " %-9s" * 6) % ("T(K)", "xx", "yy", "zz",
"yz", "xz", "xy")
for j, (t, k) in enumerate(zip(temperatures, kappa_at_sigma)):
print("%7.1f" + " %9.3f" * 6) % ((t, ) + tuple(k))
print
write_kappa_to_hdf5(temperatures,
mesh,
frequency=frequencies,
group_velocity=gv,
heat_capacity=mode_cv,
kappa=kappa_at_sigma,
mode_kappa=mode_kappa[i],
gamma=gamma[i],
gamma_isotope=gamma_isotope_at_sigma,
averaged_pp_interaction=ave_pp,
qpoint=qpoints,
weight=weights,
mesh_divisors=mesh_divisors,
sigma=sigma,
filename=filename)
def _write_kappa(lbte, filename=None, log_level=0):
temperatures = lbte.get_temperatures()
sigmas = lbte.get_sigmas()
gamma = lbte.get_gamma()
mesh = lbte.get_mesh_numbers()
frequencies = lbte.get_frequencies()
gv = lbte.get_group_velocities()
ave_pp = lbte.get_averaged_pp_interaction()
qpoints = lbte.get_qpoints()
kappa = lbte.get_kappa()
mode_kappa = lbte.get_mode_kappa()
coleigs = lbte.get_collision_eigenvalues()
for i, sigma in enumerate(sigmas):
write_kappa_to_hdf5(temperatures,
mesh,
frequency=frequencies,
group_velocity=gv,
kappa=kappa[i],
mode_kappa=mode_kappa[i],
gamma=gamma[i],
averaged_pp_interaction=ave_pp,
qpoint=qpoints,
sigma=sigma,
filename=filename,
verbose=log_level)
write_collision_eigenvalues_to_hdf5(temperatures,
mesh,
coleigs[i],
sigma=sigma,
filename=filename,
verbose=log_level)
def _write_gamma(br, interaction, i, filename=None):
grid_points = br.get_grid_points()
group_velocities = br.get_group_velocities()
mode_heat_capacities = br.get_mode_heat_capacities()
mspp = br.get_mean_square_pp_strength()
mesh = br.get_mesh_numbers()
mesh_divisors = br.get_mesh_divisors()
temperatures = br.get_temperatures()
gamma = br.get_gamma()
gamma_isotope = br.get_gamma_isotope()
sigmas = br.get_sigmas()
gp = grid_points[i]
frequencies = interaction.get_phonons()[0][gp]
for j, sigma in enumerate(sigmas):
if gamma_isotope is not None:
gamma_isotope_at_sigma = gamma_isotope[j, i]
else:
gamma_isotope_at_sigma = None
write_kappa_to_hdf5(temperatures,
mesh,
frequency=frequencies,
group_velocity=group_velocities[i],
heat_capacity=mode_heat_capacities[i],
kappa=None,
gamma=gamma[j, :, i],
gamma_isotope=gamma_isotope_at_sigma,
mspp=mspp[i],
mesh_divisors=mesh_divisors,
grid_point=gp,
sigma=sigma,
filename=filename)
def _write_kappa(lbte, filename=None, log_level=0):
temperatures = lbte.get_temperatures()
sigmas = lbte.get_sigmas()
gamma = lbte.get_gamma()
mesh = lbte.get_mesh_numbers()
frequencies = lbte.get_frequencies()
gv = lbte.get_group_velocities()
ave_pp = lbte.get_averaged_pp_interaction()
qpoints = lbte.get_qpoints()
kappa = lbte.get_kappa()
mode_kappa = lbte.get_mode_kappa()
coleigs = lbte.get_collision_eigenvalues()
for i, sigma in enumerate(sigmas):
write_kappa_to_hdf5(temperatures,
mesh,
frequency=frequencies,
group_velocity=gv,
kappa=kappa[i],
mode_kappa=mode_kappa[i],
gamma=gamma[i],
averaged_pp_interaction=ave_pp,
qpoint=qpoints,
sigma=sigma,
filename=filename,
verbose=log_level)
write_collision_eigenvalues_to_hdf5(temperatures,
mesh,
coleigs[i],
sigma=sigma,
filename=filename,
verbose=log_level)
def _write_kappa(br, filename=None, log_level=0):
temperatures = br.get_temperatures()
sigmas = br.get_sigmas()
gamma = br.get_gamma()
gamma_isotope = br.get_gamma_isotope()
mesh = br.get_mesh_numbers()
mesh_divisors = br.get_mesh_divisors()
frequencies = br.get_frequencies()
gv = br.get_group_velocities()
mode_cv = br.get_mode_heat_capacities()
ave_pp = br.get_averaged_pp_interaction()
qpoints = br.get_qpoints()
weights = br.get_grid_weights()
kappa = br.get_kappa()
mode_kappa = br.get_mode_kappa()
num_ignored_phonon_modes = br.get_number_of_ignored_phonon_modes()
num_band = br.get_frequencies().shape[1]
num_phonon_modes = br.get_number_of_sampling_grid_points() * num_band
for i, sigma in enumerate(sigmas):
kappa_at_sigma = kappa[i]
if gamma_isotope is not None:
gamma_isotope_at_sigma = gamma_isotope[i]
else:
gamma_isotope_at_sigma = None
if log_level:
print "----------- Thermal conductivity (W/m-k)",
if sigma:
print "for sigma=%s -----------" % sigma
else:
print "with tetrahedron method -----------"
if log_level > 1:
print ("#%6s " + " %-9s" * 6 + "#ipm") % (
"T(K)", "xx", "yy", "zz", "yz", "xz", "xy")
for j, (t, k) in enumerate(zip(temperatures, kappa_at_sigma)):
print ("%7.1f" + " %9.3f" * 6 + " %d/%d") % (
(t,) + tuple(k) +
(num_ignored_phonon_modes[i, j], num_phonon_modes))
else:
print ("#%6s " + " %-9s" * 6) % ("T(K)", "xx", "yy", "zz",
"yz", "xz", "xy")
for j, (t, k) in enumerate(zip(temperatures, kappa_at_sigma)):
print ("%7.1f" + " %9.3f" * 6) % ((t,) + tuple(k))
print
write_kappa_to_hdf5(temperatures,
mesh,
frequency=frequencies,
group_velocity=gv,
heat_capacity=mode_cv,
kappa=kappa_at_sigma,
mode_kappa=mode_kappa[i],
gamma=gamma[i],
gamma_isotope=gamma_isotope_at_sigma,
averaged_pp_interaction=ave_pp,
qpoint=qpoints,
weight=weights,
mesh_divisors=mesh_divisors,
sigma=sigma,
filename=filename)
def _write_gamma(br, interaction, i, filename=None):
grid_points = br.get_grid_points()
group_velocities = br.get_group_velocities()
mode_heat_capacities = br.get_mode_heat_capacities()
ave_pp = br.get_averaged_pp_interaction()
mesh = br.get_mesh_numbers()
mesh_divisors = br.get_mesh_divisors()
temperatures = br.get_temperatures()
gamma = br.get_gamma()
gamma_isotope = br.get_gamma_isotope()
sigmas = br.get_sigmas()
gp = grid_points[i]
frequencies = interaction.get_phonons()[0][gp]
for j, sigma in enumerate(sigmas):
if gamma_isotope is not None:
gamma_isotope_at_sigma = gamma_isotope[j, i]
else:
gamma_isotope_at_sigma = None
write_kappa_to_hdf5(temperatures,
mesh,
frequency=frequencies,
group_velocity=group_velocities[i],
heat_capacity=mode_heat_capacities[:, i],
kappa=None,
gamma=gamma[j, :, i],
gamma_isotope=gamma_isotope_at_sigma,
averaged_pp_interaction=ave_pp[i],
mesh_divisors=mesh_divisors,
grid_point=gp,
sigma=sigma,
filename=filename)
def _write_gamma(br, interaction, i, filename=None, verbose=True):
grid_points = br.get_grid_points()
group_velocities = br.get_group_velocities()
mode_heat_capacities = br.get_mode_heat_capacities()
ave_pp = br.get_averaged_pp_interaction()
mesh = br.get_mesh_numbers()
mesh_divisors = br.get_mesh_divisors()
temperatures = br.get_temperatures()
gamma = br.get_gamma()
gamma_isotope = br.get_gamma_isotope()
sigmas = br.get_sigmas()
gp = grid_points[i]
if _all_bands_exist(interaction):
frequencies = interaction.get_phonons()[0][gp]
for j, sigma in enumerate(sigmas):
if gamma_isotope is not None:
gamma_isotope_at_sigma = gamma_isotope[j, i]
else:
gamma_isotope_at_sigma = None
write_kappa_to_hdf5(temperatures,
mesh,
frequency=frequencies,
group_velocity=group_velocities[i],
heat_capacity=mode_heat_capacities[:, i],
kappa=None,
gamma=gamma[j, :, i],
gamma_isotope=gamma_isotope_at_sigma,
averaged_pp_interaction=ave_pp[i],
mesh_divisors=mesh_divisors,
grid_point=gp,
sigma=sigma,
filename=filename,
verbose=verbose)
else:
for j, sigma in enumerate(sigmas):
for k, bi in enumerate(interaction.get_band_indices()):
frequencies = interaction.get_phonons()[0][gp, k]
if gamma_isotope is not None:
gamma_isotope_at_sigma = gamma_isotope[j, i, k]
else:
gamma_isotope_at_sigma = None
write_kappa_to_hdf5(temperatures,
mesh,
frequency=frequencies,
group_velocity=group_velocities[i, k],
heat_capacity=mode_heat_capacities[:,
i,
k],
kappa=None,
gamma=gamma[j, :, i, k],
gamma_isotope=gamma_isotope_at_sigma,
averaged_pp_interaction=ave_pp[i, k],
mesh_divisors=mesh_divisors,
grid_point=gp,
band_index=bi,
sigma=sigma,
filename=filename,
verbose=verbose)
def _write_kappa(br, filename=None, log_level=0):
temperatures = br.get_temperatures()
sigmas = br.get_sigmas()
gamma = br.get_gamma()
gamma_isotope = br.get_gamma_isotope()
mesh = br.get_mesh_numbers()
mesh_divisors = br.get_mesh_divisors()
frequencies = br.get_frequencies()
gv = br.get_group_velocities()
mode_cv = br.get_mode_heat_capacities()
mspp = br.get_mean_square_pp_strength()
qpoints = br.get_qpoints()
weights = br.get_grid_weights()
# num_sampling_points = br.get_number_of_sampling_points()
kappa = br.get_kappa()
mode_kappa = br.get_mode_kappa()
for i, sigma in enumerate(sigmas):
kappa_at_sigma = kappa[i]
if gamma_isotope is not None:
gamma_isotope_at_sigma = gamma_isotope[i]
else:
gamma_isotope_at_sigma = None
if log_level:
print "----------- Thermal conductivity (W/m-k)",
if sigma:
print "for sigma=%s -----------" % sigma
else:
print "with tetrahedron method -----------"
print("#%6s " + " %-9s" * 6) % ("T(K)", "xx", "yy", "zz", "yz",
"xz", "xy")
for t, k in zip(temperatures, kappa_at_sigma):
print("%7.1f" + " %9.3f" * 6) % ((t, ) + tuple(k))
print
write_kappa_to_hdf5(temperatures,
mesh,
frequency=frequencies,
group_velocity=gv,
heat_capacity=mode_cv,
kappa=kappa_at_sigma,
mode_kappa=mode_kappa[i],
gamma=gamma[i],
gamma_isotope=gamma_isotope_at_sigma,
mspp=mspp,
qpoint=qpoints,
weight=weights,
mesh_divisors=mesh_divisors,
sigma=sigma,
filename=filename)
def _write_kappa(br, filename=None, log_level=0):
temperatures = br.get_temperatures()
sigmas = br.get_sigmas()
gamma = br.get_gamma()
gamma_isotope = br.get_gamma_isotope()
mesh = br.get_mesh_numbers()
mesh_divisors = br.get_mesh_divisors()
frequencies = br.get_frequencies()
gv = br.get_group_velocities()
mode_cv = br.get_mode_heat_capacities()
mspp = br.get_mean_square_pp_strength()
qpoints = br.get_qpoints()
weights = br.get_grid_weights()
# num_sampling_points = br.get_number_of_sampling_points()
kappa = br.get_kappa()
mode_kappa = br.get_mode_kappa()
for i, sigma in enumerate(sigmas):
kappa_at_sigma = kappa[i]
if gamma_isotope is not None:
gamma_isotope_at_sigma = gamma_isotope[i]
else:
gamma_isotope_at_sigma = None
if log_level:
print "----------- Thermal conductivity (W/m-k)",
if sigma:
print "for sigma=%s -----------" % sigma
else:
print "with tetrahedron method -----------"
print ("#%6s " + " %-9s" * 6) % ("T(K)", "xx", "yy", "zz",
"yz", "xz", "xy")
for t, k in zip(temperatures, kappa_at_sigma):
print ("%7.1f" + " %9.3f" * 6) % ((t,) + tuple(k))
print
write_kappa_to_hdf5(temperatures,
mesh,
frequency=frequencies,
group_velocity=gv,
heat_capacity=mode_cv,
kappa=kappa_at_sigma,
mode_kappa=mode_kappa[i],
gamma=gamma[i],
gamma_isotope=gamma_isotope_at_sigma,
mspp=mspp,
qpoint=qpoints,
weight=weights,
mesh_divisors=mesh_divisors,
sigma=sigma,
filename=filename)
def _write_gamma(self, i, grid_point):
for j, sigma in enumerate(self._sigmas):
write_kappa_to_hdf5(
self._gamma[j, i],
self._temperatures,
self._mesh,
frequency=self._frequencies[i],
group_velocity=self._gv[i],
heat_capacity=self._cv[i],
kappa=self._kappa[j, i],
mesh_divisors=self._mesh_divisors,
grid_point=grid_point,
sigma=sigma,
filename=self._filename)
def _write_kappa(lbte, filename=None, log_level=0):
temperatures = lbte.get_temperatures()
sigmas = lbte.get_sigmas()
gamma = lbte.get_gamma()
mesh = lbte.get_mesh_numbers()
frequencies = lbte.get_frequencies()
gv = lbte.get_group_velocities()
mspp = lbte.get_mean_square_pp_strength()
qpoints = lbte.get_qpoints()
kappa = lbte.get_kappa()
for i, sigma in enumerate(sigmas):
write_kappa_to_hdf5(temperatures,
mesh,
frequency=frequencies,
group_velocity=gv,
kappa=kappa[i],
gamma=gamma[i],
mspp=mspp,
qpoint=qpoints,
sigma=sigma,
filename=filename)
def _write_kappa(lbte, filename=None, log_level=0):
temperatures = lbte.get_temperatures()
sigmas = lbte.get_sigmas()
gamma = lbte.get_gamma()
mesh = lbte.get_mesh_numbers()
frequencies = lbte.get_frequencies()
gv = lbte.get_group_velocities()
mspp = lbte.get_mean_square_pp_strength()
qpoints = lbte.get_qpoints()
kappa = lbte.get_kappa()
mode_kappa = lbte.get_mode_kappa()
for i, sigma in enumerate(sigmas):
write_kappa_to_hdf5(temperatures,
mesh,
frequency=frequencies,
group_velocity=gv,
kappa=kappa[i],
mode_kappa=mode_kappa[i],
gamma=gamma[i],
mspp=mspp,
qpoint=qpoints,
sigma=sigma,
filename=filename)
def get_thermal_conductivity(self,
sigmas=None,
temperatures=None,
grid_points=None,
mesh_divisors=None,
coarse_mesh_shifts=None,
cutoff_lifetime=1e-4, # in second
diff_kappa = 1e-5, # relative
nu=None,
no_kappa_stars=False,
gv_delta_q=1e-4, # for group velocity
write_gamma=False,
read_gamma=False,
kappa_write_step=None,
filename=None):
br = conductivity_RTA(self._interaction,
symmetry=self._primitive_symmetry,
sigmas=sigmas,
asigma_step= self._asigma_step,
temperatures=temperatures,
mesh_divisors=mesh_divisors,
coarse_mesh_shifts=coarse_mesh_shifts,
grid_points=grid_points,
cutoff_lifetime=cutoff_lifetime,
diff_kappa= diff_kappa,
nu=nu,
no_kappa_stars=no_kappa_stars,
gv_delta_q=gv_delta_q,
log_level=self._log_level,
write_tecplot = self._write_tecplot,
kappa_write_step=kappa_write_step,
is_thm=self._is_thm,
filename=filename)
if read_gamma:
for sigma in sigmas:
self.read_gamma_at_sigma(sigma)
br.calculate_kappa(write_gamma=write_gamma)
mode_kappa = br.get_kappa()
gamma = br.get_gamma()
gamma_N=br._gamma_N
gamma_U=br._gamma_U
if self._log_level:
br.print_kappa()
if grid_points is None:
temperatures = br.get_temperatures()
for i, sigma in enumerate(sigmas):
kappa = mode_kappa[i]
write_kappa_to_hdf5(gamma[i],
temperatures,
br.get_mesh_numbers(),
frequency=br.get_frequencies(),
group_velocity=br.get_group_velocities(),
heat_capacity=br.get_mode_heat_capacities(),
kappa=kappa,
qpoint=br.get_qpoints(),
weight=br.get_grid_weights(),
mesh_divisors=br.get_mesh_divisors(),
sigma=sigma,
filename=filename,
gnu=(gamma_N[i],gamma_U[i]))
if self._write_tecplot:
for j,temp in enumerate(temperatures):
write_kappa_to_tecplot_BZ(np.where(gamma[i,:,j]>1e-8, gamma[i,:,j],0),
temp,
br.get_mesh_numbers(),
bz_q_address=br._bz_grid_address / br.get_mesh_numbers().astype(float),
tetrahedrdons=br._unique_vertices,
bz_to_pp_mapping=br._bz_to_pp_map,
rec_lattice=np.linalg.inv(br._primitive.get_cell()),
spg_indices_mapping=br._irr_index_mapping,
spg_rotation_mapping=br._rot_mappings,
frequency=br.get_frequencies(),
group_velocity=br.get_group_velocities(),
heat_capacity=br.get_mode_heat_capacities()[:,j],
kappa=kappa[:,j],
weight=br.get_grid_weights(),
sigma=sigma,
filename="bz")
self._kappa = mode_kappa
self._gamma = gamma
self._br=br
def _write_gamma(br, interaction, i, filename=None, verbose=True):
grid_points = br.get_grid_points()
group_velocities = br.get_group_velocities()
mode_heat_capacities = br.get_mode_heat_capacities()
ave_pp = br.get_averaged_pp_interaction()
mesh = br.get_mesh_numbers()
mesh_divisors = br.get_mesh_divisors()
temperatures = br.get_temperatures()
gamma = br.get_gamma()
gamma_isotope = br.get_gamma_isotope()
sigmas = br.get_sigmas()
volume = interaction.get_primitive().get_volume()
gp = grid_points[i]
if _all_bands_exist(interaction):
if ave_pp is None:
ave_pp_i = None
else:
ave_pp_i = ave_pp[i]
frequencies = interaction.get_phonons()[0][gp]
for j, sigma in enumerate(sigmas):
if gamma_isotope is not None:
gamma_isotope_at_sigma = gamma_isotope[j, i]
else:
gamma_isotope_at_sigma = None
write_kappa_to_hdf5(temperatures,
mesh,
frequency=frequencies,
group_velocity=group_velocities[i],
heat_capacity=mode_heat_capacities[:, i],
gamma=gamma[j, :, i],
gamma_isotope=gamma_isotope_at_sigma,
averaged_pp_interaction=ave_pp_i,
mesh_divisors=mesh_divisors,
grid_point=gp,
sigma=sigma,
kappa_unit_conversion=unit_to_WmK / volume,
filename=filename,
verbose=verbose)
else:
for j, sigma in enumerate(sigmas):
for k, bi in enumerate(interaction.get_band_indices()):
if ave_pp is None:
ave_pp_ik = None
else:
ave_pp_ik = ave_pp[i, k]
frequencies = interaction.get_phonons()[0][gp, k]
if gamma_isotope is not None:
gamma_isotope_at_sigma = gamma_isotope[j, i, k]
else:
gamma_isotope_at_sigma = None
write_kappa_to_hdf5(
temperatures,
mesh,
frequency=frequencies,
group_velocity=group_velocities[i, k],
heat_capacity=mode_heat_capacities[:, i, k],
gamma=gamma[j, :, i, k],
gamma_isotope=gamma_isotope_at_sigma,
averaged_pp_interaction=ave_pp_ik,
mesh_divisors=mesh_divisors,
grid_point=gp,
band_index=bi,
sigma=sigma,
kappa_unit_conversion=unit_to_WmK / volume,
filename=filename,
verbose=verbose)
def get_thermal_conductivity(
self,
sigmas=[0.1],
t_max=1500,
t_min=0,
t_step=10,
grid_points=None,
mesh_divisors=None,
coarse_mesh_shifts=None,
cutoff_lifetime=1e-4, # in second
diff_gamma=1e-5, # in THz
is_nu=False,
no_kappa_stars=False,
gv_delta_q=1e-4, # for group velocity
write_gamma=False,
read_gamma=False,
write_amplitude=False,
read_amplitude=False,
filename=None):
br = conductivity_RTA(self._interaction,
sigmas=sigmas,
asigma_step=self._adaptive_sigma_step,
t_max=t_max,
t_min=t_min,
t_step=t_step,
mesh_divisors=mesh_divisors,
coarse_mesh_shifts=coarse_mesh_shifts,
cutoff_lifetime=cutoff_lifetime,
diff_kappa=diff_gamma,
nu=is_nu,
no_kappa_stars=no_kappa_stars,
gv_delta_q=gv_delta_q,
log_level=self._log_level,
write_tecplot=self._write_tecplot,
filename=filename)
br.set_grid_points(grid_points)
if read_gamma:
gamma = []
for sigma in sigmas:
try:
properties = read_kappa_from_hdf5(
br.get_mesh_numbers(),
mesh_divisors=br.get_mesh_divisors(),
sigma=sigma,
filename=br._filename)
if properties is None:
raise ValueError
tbr = br.get_temperatures()
ts_pos0, ts_pos1 = np.where(
properties['temperature'] == tbr.reshape(-1, 1))
br.set_temperatures(tbr[ts_pos0])
gamma_at_sigma = properties['gamma'][:, ts_pos1]
gamma.append(gamma_at_sigma)
br.set_gamma(np.double(gamma))
except ValueError:
properties = []
for point in br.get_grid_points():
property = read_kappa_from_hdf5(
br.get_mesh_numbers(),
mesh_divisors=br.get_mesh_divisors(),
grid_point=point,
sigma=sigma,
filename=br._filename)
properties.append(property)
tbr = br.get_temperatures()
ts_pos0, ts_pos1 = np.where(
properties[0]['temperature'] == tbr.reshape(-1, 1))
br.set_temperatures(tbr[ts_pos0])
gamma_at_sigma = np.array(
[p['gamma'][ts_pos1] for p in properties],
dtype="double")
gamma.append(gamma_at_sigma)
br.set_gamma(np.double(gamma))
br.calculate_kappa(write_amplitude=write_amplitude,
read_amplitude=read_amplitude,
write_gamma=write_gamma)
mode_kappa = br.get_kappa()
gamma = br.get_gamma()
gamma_N = br._gamma_N
gamma_U = br._gamma_U
if self._log_level:
br.print_kappa()
if grid_points is None:
temperatures = br.get_temperatures()
for i, sigma in enumerate(sigmas):
kappa = mode_kappa[i]
write_kappa_to_hdf5(
gamma[i],
temperatures,
br.get_mesh_numbers(),
frequency=br.get_frequencies(),
group_velocity=br.get_group_velocities(),
heat_capacity=br.get_mode_heat_capacities(),
kappa=kappa,
qpoint=br.get_qpoints(),
weight=br.get_grid_weights(),
mesh_divisors=br.get_mesh_divisors(),
sigma=sigma,
filename=filename,
gnu=(gamma_N[i], gamma_U[i]))
if self._write_tecplot:
for j, temp in enumerate(temperatures):
write_kappa_to_tecplot_BZ(
np.where(gamma[i, :, j] > 1e-8, gamma[i, :, j], 0),
temp,
br.get_mesh_numbers(),
bz_q_address=br._bz_grid_address /
br.get_mesh_numbers().astype(float),
tetrahedrdons=br._unique_vertices,
bz_to_pp_mapping=br._bz_to_pp_map,
rec_lattice=np.linalg.inv(
br._primitive.get_cell()),
spg_indices_mapping=br._irr_index_mapping,
spg_rotation_mapping=br._rot_mappings,
frequency=br.get_frequencies(),
group_velocity=br.get_group_velocities(),
heat_capacity=br.get_mode_heat_capacities()[:, j],
kappa=kappa[:, j],
weight=br.get_grid_weights(),
sigma=sigma,
filename="bz")
self._kappa = mode_kappa
self._gamma = gamma
self._br = br
def get_kappa_ite_cg(
self,
sigmas=[0.2],
temperatures=None,
grid_points=None,
max_ite=None,
no_kappa_stars=False,
diff_kappa=1e-5, # relative value
write_gamma=False,
read_gamma=False,
read_col=False,
write_col=False,
filename="ite_cg"):
bis = conductivity_ITE_CG(
self._interaction, #Iterative Boltzmann solutions
symmetry=self._primitive_symmetry,
sigmas=sigmas,
grid_points=grid_points,
temperatures=temperatures,
max_ite=max_ite,
adaptive_sigma_step=self._asigma_step,
no_kappa_stars=no_kappa_stars,
diff_kappa=diff_kappa,
mass_variances=self._mass_variances,
length=self._length,
log_level=self._log_level,
read_gamma=read_gamma,
write_gamma=write_gamma,
read_col=read_col,
write_col=write_col,
is_thm=self._is_thm,
filename=filename)
for s, sigma in enumerate(sigmas):
write_kappa_to_hdf5(bis._gamma[s],
bis._temperatures,
bis._mesh,
frequency=bis._frequencies,
group_velocity=bis._gv,
heat_capacity=bis.get_mode_heat_capacities(),
kappa=bis._kappa[s],
qpoint=bis._qpoints,
weight=bis._grid_weights,
sigma=sigma,
filename="smrt")
try:
for bi in bis:
bi.set_kappa()
print "After %d iteration(s), the thermal conductivities are recalculated to be (W/mK)" % bi._ite_step
bi.print_kappa()
except KeyboardInterrupt:
print
print "A keyboard Interruption is captured. The iterations are terminated!"
print "The kappa is retrieved from the last iterations."
bis._F = bis._F_prev
print "Final thermal conductivity (W/mK)"
for s, sigma in enumerate(sigmas):
bis.set_equivalent_gamma_at_sigma(s)
bis.set_kappa_at_sigma(s)
write_kappa_to_hdf5(bis._gamma[s],
bis._temperatures,
bis._mesh,
frequency=bis._frequencies,
group_velocity=bis._gv,
heat_capacity=bis.get_mode_heat_capacities(),
kappa=bis._kappa[s],
qpoint=bis._qpoints,
weight=bis._grid_weights,
sigma=sigma,
filename=bis._filename)
self._gamma = bis._gamma
self._kappa = bis._kappa
bis.print_kappa()
def get_thermal_conductivity(
self,
sigmas=None,
temperatures=None,
grid_points=None,
mesh_divisors=None,
coarse_mesh_shifts=None,
cutoff_lifetime=1e-4, # in second
diff_kappa=1e-5, # relative
nu=None,
no_kappa_stars=False,
gv_delta_q=1e-4, # for group velocity
write_gamma=False,
read_gamma=False,
kappa_write_step=None,
filename=None):
br = conductivity_RTA(self._interaction,
symmetry=self._primitive_symmetry,
sigmas=sigmas,
asigma_step=self._asigma_step,
temperatures=temperatures,
mesh_divisors=mesh_divisors,
coarse_mesh_shifts=coarse_mesh_shifts,
grid_points=grid_points,
cutoff_lifetime=cutoff_lifetime,
diff_kappa=diff_kappa,
nu=nu,
no_kappa_stars=no_kappa_stars,
gv_delta_q=gv_delta_q,
log_level=self._log_level,
write_tecplot=self._write_tecplot,
kappa_write_step=kappa_write_step,
is_thm=self._is_thm,
filename=filename)
if read_gamma:
for sigma in sigmas:
self.read_gamma_at_sigma(sigma)
br.calculate_kappa(write_gamma=write_gamma)
mode_kappa = br.get_kappa()
gamma = br.get_gamma()
gamma_N = br._gamma_N
gamma_U = br._gamma_U
if self._log_level:
br.print_kappa()
if grid_points is None:
temperatures = br.get_temperatures()
for i, sigma in enumerate(sigmas):
kappa = mode_kappa[i]
write_kappa_to_hdf5(
gamma[i],
temperatures,
br.get_mesh_numbers(),
frequency=br.get_frequencies(),
group_velocity=br.get_group_velocities(),
heat_capacity=br.get_mode_heat_capacities(),
kappa=kappa,
qpoint=br.get_qpoints(),
weight=br.get_grid_weights(),
mesh_divisors=br.get_mesh_divisors(),
sigma=sigma,
filename=filename,
gnu=(gamma_N[i], gamma_U[i]))
if self._write_tecplot:
for j, temp in enumerate(temperatures):
write_kappa_to_tecplot_BZ(
np.where(gamma[i, :, j] > 1e-8, gamma[i, :, j], 0),
temp,
br.get_mesh_numbers(),
bz_q_address=br._bz_grid_address /
br.get_mesh_numbers().astype(float),
tetrahedrdons=br._unique_vertices,
bz_to_pp_mapping=br._bz_to_pp_map,
rec_lattice=np.linalg.inv(
br._primitive.get_cell()),
spg_indices_mapping=br._irr_index_mapping,
spg_rotation_mapping=br._rot_mappings,
frequency=br.get_frequencies(),
group_velocity=br.get_group_velocities(),
heat_capacity=br.get_mode_heat_capacities()[:, j],
kappa=kappa[:, j],
weight=br.get_grid_weights(),
sigma=sigma,
filename="bz")
self._kappa = mode_kappa
self._gamma = gamma
self._br = br
def get_thermal_conductivity(self,
sigmas=[0.1],
t_max=1500,
t_min=0,
t_step=10,
grid_points=None,
mesh_divisors=None,
coarse_mesh_shifts=None,
cutoff_lifetime=1e-4, # in second
diff_gamma = 1e-5, # in THz
is_nu=False,
no_kappa_stars=False,
gv_delta_q=1e-4, # for group velocity
write_gamma=False,
read_gamma=False,
write_amplitude=False,
read_amplitude=False,
filename=None):
br = conductivity_RTA(self._interaction,
sigmas=sigmas,
asigma_step= self._adaptive_sigma_step,
t_max=t_max,
t_min=t_min,
t_step=t_step,
mesh_divisors=mesh_divisors,
coarse_mesh_shifts=coarse_mesh_shifts,
cutoff_lifetime=cutoff_lifetime,
diff_kappa= diff_gamma,
nu=is_nu,
no_kappa_stars=no_kappa_stars,
gv_delta_q=gv_delta_q,
log_level=self._log_level,
write_tecplot = self._write_tecplot,
filename=filename)
br.set_grid_points(grid_points)
if read_gamma:
gamma = []
for sigma in sigmas:
try:
properties = read_kappa_from_hdf5(
br.get_mesh_numbers(),
mesh_divisors=br.get_mesh_divisors(),
sigma=sigma,
filename=br._filename)
if properties is None:
raise ValueError
tbr = br.get_temperatures()
ts_pos0, ts_pos1 = np.where(properties['temperature'] == tbr.reshape(-1,1))
br.set_temperatures(tbr[ts_pos0])
gamma_at_sigma=properties['gamma'][:,ts_pos1]
gamma.append(gamma_at_sigma)
br.set_gamma(np.double(gamma))
except ValueError:
properties = []
for point in br.get_grid_points():
property = read_kappa_from_hdf5(
br.get_mesh_numbers(),
mesh_divisors=br.get_mesh_divisors(),
grid_point=point,
sigma=sigma,
filename=br._filename)
properties.append(property)
tbr = br.get_temperatures()
ts_pos0,ts_pos1 = np.where(properties[0]['temperature'] == tbr.reshape(-1,1))
br.set_temperatures(tbr[ts_pos0])
gamma_at_sigma = np.array([p['gamma'][ts_pos1] for p in properties], dtype="double")
gamma.append(gamma_at_sigma)
br.set_gamma(np.double(gamma))
br.calculate_kappa(write_amplitude=write_amplitude,
read_amplitude=read_amplitude,
write_gamma=write_gamma)
mode_kappa = br.get_kappa()
gamma = br.get_gamma()
gamma_N=br._gamma_N
gamma_U=br._gamma_U
if self._log_level:
br.print_kappa()
if grid_points is None:
temperatures = br.get_temperatures()
for i, sigma in enumerate(sigmas):
kappa = mode_kappa[i]
write_kappa_to_hdf5(gamma[i],
temperatures,
br.get_mesh_numbers(),
frequency=br.get_frequencies(),
group_velocity=br.get_group_velocities(),
heat_capacity=br.get_mode_heat_capacities(),
kappa=kappa,
qpoint=br.get_qpoints(),
weight=br.get_grid_weights(),
mesh_divisors=br.get_mesh_divisors(),
sigma=sigma,
filename=filename,
gnu=(gamma_N[i],gamma_U[i]))
if self._write_tecplot:
for j,temp in enumerate(temperatures):
write_kappa_to_tecplot_BZ(np.where(gamma[i,:,j]>1e-8, gamma[i,:,j],0),
temp,
br.get_mesh_numbers(),
bz_q_address=br._bz_grid_address / br.get_mesh_numbers().astype(float),
tetrahedrdons=br._unique_vertices,
bz_to_pp_mapping=br._bz_to_pp_map,
rec_lattice=np.linalg.inv(br._primitive.get_cell()),
spg_indices_mapping=br._irr_index_mapping,
spg_rotation_mapping=br._rot_mappings,
frequency=br.get_frequencies(),
group_velocity=br.get_group_velocities(),
heat_capacity=br.get_mode_heat_capacities()[:,j],
kappa=kappa[:,j],
weight=br.get_grid_weights(),
sigma=sigma,
filename="bz")
self._kappa = mode_kappa
self._gamma = gamma
self._br=br
def get_kappa_ite_cg(self,
sigmas=[0.2],
temperatures=None,
grid_points=None,
max_ite = None,
no_kappa_stars=False,
diff_kappa = 1e-5, # relative value
write_gamma=False,
read_gamma=False,
read_col=False,
write_col=False,
filename="ite_cg"):
bis=conductivity_ITE_CG(self._interaction, #Iterative Boltzmann solutions
symmetry=self._primitive_symmetry,
sigmas=sigmas,
grid_points = grid_points,
temperatures=temperatures,
max_ite = max_ite,
adaptive_sigma_step = self._asigma_step,
no_kappa_stars=no_kappa_stars,
diff_kappa= diff_kappa,
mass_variances=self._mass_variances,
length=self._length,
log_level=self._log_level,
read_gamma = read_gamma,
write_gamma = write_gamma,
read_col = read_col,
write_col=write_col,
is_thm=self._is_thm,
filename=filename)
for s, sigma in enumerate(sigmas):
write_kappa_to_hdf5(bis._gamma[s],
bis._temperatures,
bis._mesh,
frequency=bis._frequencies,
group_velocity=bis._gv,
heat_capacity=bis.get_mode_heat_capacities(),
kappa=bis._kappa[s],
qpoint=bis._qpoints,
weight=bis._grid_weights,
sigma=sigma,
filename="smrt")
try:
for bi in bis:
bi.set_kappa()
print "After %d iteration(s), the thermal conductivities are recalculated to be (W/mK)"%bi._ite_step
bi.print_kappa()
except KeyboardInterrupt:
print
print "A keyboard Interruption is captured. The iterations are terminated!"
print "The kappa is retrieved from the last iterations."
bis._F = bis._F_prev
print "Final thermal conductivity (W/mK)"
for s, sigma in enumerate(sigmas):
bis.set_equivalent_gamma_at_sigma(s)
bis.set_kappa_at_sigma(s)
write_kappa_to_hdf5(bis._gamma[s],
bis._temperatures,
bis._mesh,
frequency=bis._frequencies,
group_velocity=bis._gv,
heat_capacity=bis.get_mode_heat_capacities(),
kappa=bis._kappa[s],
qpoint=bis._qpoints,
weight=bis._grid_weights,
sigma=sigma,
filename=bis._filename)
self._gamma=bis._gamma
self._kappa=bis._kappa
bis.print_kappa()
