scnc
/
phono3py
mirror of https://github.com/phonopy/phono3py.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove unit conversion factor in C routines

This commit is contained in:
Atsushi Togo 2025-04-29 22:31:05 +09:00
parent 6264dc5e35
commit 855ce1c3c2
33 changed files with 299 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

219
c/_phono3py.cpp
View File

@ -65,15 +65,15 @@ void py_get_interaction(nb::ndarray<> py_fc3_normal_squared,
Darray *fc3_normal_squared; Darray *fc3_normal_squared;
Darray *freqs; Darray *freqs;
_lapack_complex_double *eigvecs; _lapack_complex_double *eigvecs;
int64_t(*triplets)[3]; int64_t (*triplets)[3];
int64_t num_triplets; int64_t num_triplets;
char *g_zero; char *g_zero;
int64_t(*bz_grid_addresses)[3]; int64_t (*bz_grid_addresses)[3];
int64_t *D_diag; int64_t *D_diag;
int64_t(*Q)[3]; int64_t (*Q)[3];
double *fc3; double *fc3;
double(*svecs)[3]; double (*svecs)[3];
int64_t(*multi)[2]; int64_t (*multi)[2];
double *masses; double *masses;
char *all_shortest; char *all_shortest;
int64_t *p2s; int64_t *p2s;
@ -88,23 +88,23 @@ void py_get_interaction(nb::ndarray<> py_fc3_normal_squared,
/* npy_cdouble and lapack_complex_double may not be compatible. */ /* npy_cdouble and lapack_complex_double may not be compatible. */
/* So eigenvectors should not be used in Python side */ /* So eigenvectors should not be used in Python side */
eigvecs = (_lapack_complex_double *)py_eigenvectors.data(); eigvecs = (_lapack_complex_double *)py_eigenvectors.data();
triplets = (int64_t(*)[3])py_triplets.data(); triplets = (int64_t (*)[3])py_triplets.data();
num_triplets = (int64_t)py_triplets.shape(0); num_triplets = (int64_t)py_triplets.shape(0);
g_zero = (char *)py_g_zero.data(); g_zero = (char *)py_g_zero.data();
bz_grid_addresses = (int64_t(*)[3])py_bz_grid_addresses.data(); bz_grid_addresses = (int64_t (*)[3])py_bz_grid_addresses.data();
D_diag = (int64_t *)py_D_diag.data(); D_diag = (int64_t *)py_D_diag.data();
Q = (int64_t(*)[3])py_Q.data(); Q = (int64_t (*)[3])py_Q.data();
fc3 = (double *)py_fc3.data(); fc3 = (double *)py_fc3.data();
if (py_fc3.shape(0) == py_fc3.shape(1)) { if (py_fc3.shape(0) == py_fc3.shape(1)) {
is_compact_fc3 = 0; is_compact_fc3 = 0;
} else { } else {
is_compact_fc3 = 1; is_compact_fc3 = 1;
} }
svecs = (double(*)[3])py_svecs.data(); svecs = (double (*)[3])py_svecs.data();
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
multi_dims[i] = py_multi.shape(i); multi_dims[i] = py_multi.shape(i);
} }
multi = (int64_t(*)[2])py_multi.data(); multi = (int64_t (*)[2])py_multi.data();
masses = (double *)py_masses.data(); masses = (double *)py_masses.data();
p2s = (int64_t *)py_p2s_map.data(); p2s = (int64_t *)py_p2s_map.data();
s2p = (int64_t *)py_s2p_map.data(); s2p = (int64_t *)py_s2p_map.data();
@ -131,74 +131,74 @@ void py_get_pp_collision(
int64_t bz_grid_type, nb::ndarray<> py_D_diag, nb::ndarray<> py_Q, int64_t bz_grid_type, nb::ndarray<> py_D_diag, nb::ndarray<> py_Q,
nb::ndarray<> py_fc3, nb::ndarray<> py_svecs, nb::ndarray<> py_multi, nb::ndarray<> py_fc3, nb::ndarray<> py_svecs, nb::ndarray<> py_multi,
nb::ndarray<> py_masses, nb::ndarray<> py_p2s_map, nb::ndarray<> py_s2p_map, nb::ndarray<> py_masses, nb::ndarray<> py_p2s_map, nb::ndarray<> py_s2p_map,
nb::ndarray<> py_band_indices, nb::ndarray<> py_temperatures, int64_t is_NU, nb::ndarray<> py_band_indices, nb::ndarray<> py_temperatures_THz,
int64_t symmetrize_fc3_q, int64_t make_r0_average, int64_t is_NU, int64_t symmetrize_fc3_q, int64_t make_r0_average,
nb::ndarray<> py_all_shortest, double cutoff_frequency, nb::ndarray<> py_all_shortest, double cutoff_frequency,
int64_t openmp_per_triplets) { int64_t openmp_per_triplets) {
double *gamma; double *gamma;
int64_t(*relative_grid_address)[4][3]; int64_t (*relative_grid_address)[4][3];
double *frequencies; double *frequencies;
_lapack_complex_double *eigenvectors; _lapack_complex_double *eigenvectors;
int64_t(*triplets)[3]; int64_t (*triplets)[3];
int64_t num_triplets; int64_t num_triplets;
int64_t *triplet_weights; int64_t *triplet_weights;
int64_t(*bz_grid_addresses)[3]; int64_t (*bz_grid_addresses)[3];
int64_t *bz_map; int64_t *bz_map;
int64_t *D_diag; int64_t *D_diag;
int64_t(*Q)[3]; int64_t (*Q)[3];
double *fc3; double *fc3;
double(*svecs)[3]; double (*svecs)[3];
int64_t(*multi)[2]; int64_t (*multi)[2];
double *masses; double *masses;
int64_t *p2s; int64_t *p2s;
int64_t *s2p; int64_t *s2p;
Larray *band_indices; Larray *band_indices;
Darray *temperatures; Darray *temperatures_THz;
char *all_shortest; char *all_shortest;
int64_t multi_dims[2]; int64_t multi_dims[2];
int64_t i; int64_t i;
int64_t is_compact_fc3; int64_t is_compact_fc3;
gamma = (double *)py_gamma.data(); gamma = (double *)py_gamma.data();
relative_grid_address = (int64_t(*)[4][3])py_relative_grid_address.data(); relative_grid_address = (int64_t (*)[4][3])py_relative_grid_address.data();
frequencies = (double *)py_frequencies.data(); frequencies = (double *)py_frequencies.data();
eigenvectors = (_lapack_complex_double *)py_eigenvectors.data(); eigenvectors = (_lapack_complex_double *)py_eigenvectors.data();
triplets = (int64_t(*)[3])py_triplets.data(); triplets = (int64_t (*)[3])py_triplets.data();
num_triplets = (int64_t)py_triplets.shape(0); num_triplets = (int64_t)py_triplets.shape(0);
triplet_weights = (int64_t *)py_triplet_weights.data(); triplet_weights = (int64_t *)py_triplet_weights.data();
bz_grid_addresses = (int64_t(*)[3])py_bz_grid_addresses.data(); bz_grid_addresses = (int64_t (*)[3])py_bz_grid_addresses.data();
bz_map = (int64_t *)py_bz_map.data(); bz_map = (int64_t *)py_bz_map.data();
D_diag = (int64_t *)py_D_diag.data(); D_diag = (int64_t *)py_D_diag.data();
Q = (int64_t(*)[3])py_Q.data(); Q = (int64_t (*)[3])py_Q.data();
fc3 = (double *)py_fc3.data(); fc3 = (double *)py_fc3.data();
if (py_fc3.shape(0) == py_fc3.shape(1)) { if (py_fc3.shape(0) == py_fc3.shape(1)) {
is_compact_fc3 = 0; is_compact_fc3 = 0;
} else { } else {
is_compact_fc3 = 1; is_compact_fc3 = 1;
} }
svecs = (double(*)[3])py_svecs.data(); svecs = (double (*)[3])py_svecs.data();
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
multi_dims[i] = py_multi.shape(i); multi_dims[i] = py_multi.shape(i);
} }
multi = (int64_t(*)[2])py_multi.data(); multi = (int64_t (*)[2])py_multi.data();
masses = (double *)py_masses.data(); masses = (double *)py_masses.data();
p2s = (int64_t *)py_p2s_map.data(); p2s = (int64_t *)py_p2s_map.data();
s2p = (int64_t *)py_s2p_map.data(); s2p = (int64_t *)py_s2p_map.data();
band_indices = convert_to_larray(py_band_indices); band_indices = convert_to_larray(py_band_indices);
temperatures = convert_to_darray(py_temperatures); temperatures_THz = convert_to_darray(py_temperatures_THz);
all_shortest = (char *)py_all_shortest.data(); all_shortest = (char *)py_all_shortest.data();
ph3py_get_pp_collision( ph3py_get_pp_collision(
gamma, relative_grid_address, frequencies, eigenvectors, triplets, gamma, relative_grid_address, frequencies, eigenvectors, triplets,
num_triplets, triplet_weights, bz_grid_addresses, bz_map, bz_grid_type, num_triplets, triplet_weights, bz_grid_addresses, bz_map, bz_grid_type,
D_diag, Q, fc3, is_compact_fc3, svecs, multi_dims, multi, masses, p2s, D_diag, Q, fc3, is_compact_fc3, svecs, multi_dims, multi, masses, p2s,
s2p, band_indices, temperatures, is_NU, symmetrize_fc3_q, s2p, band_indices, temperatures_THz, is_NU, symmetrize_fc3_q,
make_r0_average, all_shortest, cutoff_frequency, openmp_per_triplets); make_r0_average, all_shortest, cutoff_frequency, openmp_per_triplets);
free(band_indices); free(band_indices);
band_indices = NULL; band_indices = NULL;
free(temperatures); free(temperatures_THz);
temperatures = NULL; temperatures_THz = NULL;
} }
void py_get_pp_collision_with_sigma( void py_get_pp_collision_with_sigma(
@ -209,26 +209,26 @@ void py_get_pp_collision_with_sigma(
nb::ndarray<> py_Q, nb::ndarray<> py_fc3, nb::ndarray<> py_svecs, nb::ndarray<> py_Q, nb::ndarray<> py_fc3, nb::ndarray<> py_svecs,
nb::ndarray<> py_multi, nb::ndarray<> py_masses, nb::ndarray<> py_p2s_map, nb::ndarray<> py_multi, nb::ndarray<> py_masses, nb::ndarray<> py_p2s_map,
nb::ndarray<> py_s2p_map, nb::ndarray<> py_band_indices, nb::ndarray<> py_s2p_map, nb::ndarray<> py_band_indices,
nb::ndarray<> py_temperatures, int64_t is_NU, int64_t symmetrize_fc3_q, nb::ndarray<> py_temperatures_THz, int64_t is_NU, int64_t symmetrize_fc3_q,
int64_t make_r0_average, nb::ndarray<> py_all_shortest, int64_t make_r0_average, nb::ndarray<> py_all_shortest,
double cutoff_frequency, int64_t openmp_per_triplets) { double cutoff_frequency, int64_t openmp_per_triplets) {
double *gamma; double *gamma;
double *frequencies; double *frequencies;
_lapack_complex_double *eigenvectors; _lapack_complex_double *eigenvectors;
int64_t(*triplets)[3]; int64_t (*triplets)[3];
int64_t num_triplets; int64_t num_triplets;
int64_t *triplet_weights; int64_t *triplet_weights;
int64_t(*bz_grid_addresses)[3]; int64_t (*bz_grid_addresses)[3];
int64_t *D_diag; int64_t *D_diag;
int64_t(*Q)[3]; int64_t (*Q)[3];
double *fc3; double *fc3;
double(*svecs)[3]; double (*svecs)[3];
int64_t(*multi)[2]; int64_t (*multi)[2];
double *masses; double *masses;
int64_t *p2s; int64_t *p2s;
int64_t *s2p; int64_t *s2p;
Larray *band_indices; Larray *band_indices;
Darray *temperatures; Darray *temperatures_THz;
char *all_shortest; char *all_shortest;
int64_t multi_dims[2]; int64_t multi_dims[2];
int64_t i; int64_t i;
@ -237,47 +237,47 @@ void py_get_pp_collision_with_sigma(
gamma = (double *)py_gamma.data(); gamma = (double *)py_gamma.data();
frequencies = (double *)py_frequencies.data(); frequencies = (double *)py_frequencies.data();
eigenvectors = (_lapack_complex_double *)py_eigenvectors.data(); eigenvectors = (_lapack_complex_double *)py_eigenvectors.data();
triplets = (int64_t(*)[3])py_triplets.data(); triplets = (int64_t (*)[3])py_triplets.data();
num_triplets = (int64_t)py_triplets.shape(0); num_triplets = (int64_t)py_triplets.shape(0);
triplet_weights = (int64_t *)py_triplet_weights.data(); triplet_weights = (int64_t *)py_triplet_weights.data();
bz_grid_addresses = (int64_t(*)[3])py_bz_grid_addresses.data(); bz_grid_addresses = (int64_t (*)[3])py_bz_grid_addresses.data();
D_diag = (int64_t *)py_D_diag.data(); D_diag = (int64_t *)py_D_diag.data();
Q = (int64_t(*)[3])py_Q.data(); Q = (int64_t (*)[3])py_Q.data();
fc3 = (double *)py_fc3.data(); fc3 = (double *)py_fc3.data();
if (py_fc3.shape(0) == py_fc3.shape(1)) { if (py_fc3.shape(0) == py_fc3.shape(1)) {
is_compact_fc3 = 0; is_compact_fc3 = 0;
} else { } else {
is_compact_fc3 = 1; is_compact_fc3 = 1;
} }
svecs = (double(*)[3])py_svecs.data(); svecs = (double (*)[3])py_svecs.data();
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
multi_dims[i] = py_multi.shape(i); multi_dims[i] = py_multi.shape(i);
} }
multi = (int64_t(*)[2])py_multi.data(); multi = (int64_t (*)[2])py_multi.data();
masses = (double *)py_masses.data(); masses = (double *)py_masses.data();
p2s = (int64_t *)py_p2s_map.data(); p2s = (int64_t *)py_p2s_map.data();
s2p = (int64_t *)py_s2p_map.data(); s2p = (int64_t *)py_s2p_map.data();
band_indices = convert_to_larray(py_band_indices); band_indices = convert_to_larray(py_band_indices);
temperatures = convert_to_darray(py_temperatures); temperatures_THz = convert_to_darray(py_temperatures_THz);
all_shortest = (char *)py_all_shortest.data(); all_shortest = (char *)py_all_shortest.data();
ph3py_get_pp_collision_with_sigma( ph3py_get_pp_collision_with_sigma(
gamma, sigma, sigma_cutoff, frequencies, eigenvectors, triplets, gamma, sigma, sigma_cutoff, frequencies, eigenvectors, triplets,
num_triplets, triplet_weights, bz_grid_addresses, D_diag, Q, fc3, num_triplets, triplet_weights, bz_grid_addresses, D_diag, Q, fc3,
is_compact_fc3, svecs, multi_dims, multi, masses, p2s, s2p, is_compact_fc3, svecs, multi_dims, multi, masses, p2s, s2p,
band_indices, temperatures, is_NU, symmetrize_fc3_q, make_r0_average, band_indices, temperatures_THz, is_NU, symmetrize_fc3_q,
all_shortest, cutoff_frequency, openmp_per_triplets); make_r0_average, all_shortest, cutoff_frequency, openmp_per_triplets);
free(band_indices); free(band_indices);
band_indices = NULL; band_indices = NULL;
free(temperatures); free(temperatures_THz);
temperatures = NULL; temperatures_THz = NULL;
} }
void py_get_imag_self_energy_with_g( void py_get_imag_self_energy_with_g(
nb::ndarray<> py_gamma, nb::ndarray<> py_fc3_normal_squared, nb::ndarray<> py_gamma, nb::ndarray<> py_fc3_normal_squared,
nb::ndarray<> py_triplets, nb::ndarray<> py_triplet_weights, nb::ndarray<> py_triplets, nb::ndarray<> py_triplet_weights,
nb::ndarray<> py_frequencies, double temperature, nb::ndarray<> py_g, nb::ndarray<> py_frequencies, double temperature_THz, nb::ndarray<> py_g,
nb::ndarray<> py_g_zero, double cutoff_frequency, nb::ndarray<> py_g_zero, double cutoff_frequency,
int64_t frequency_point_index) { int64_t frequency_point_index) {
Darray *fc3_normal_squared; Darray *fc3_normal_squared;
@ -285,7 +285,7 @@ void py_get_imag_self_energy_with_g(
double *g; double *g;
char *g_zero; char *g_zero;
double *frequencies; double *frequencies;
int64_t(*triplets)[3]; int64_t (*triplets)[3];
int64_t *triplet_weights; int64_t *triplet_weights;
int64_t num_frequency_points; int64_t num_frequency_points;
@ -294,13 +294,13 @@ void py_get_imag_self_energy_with_g(
g = (double *)py_g.data(); g = (double *)py_g.data();
g_zero = (char *)py_g_zero.data(); g_zero = (char *)py_g_zero.data();
frequencies = (double *)py_frequencies.data(); frequencies = (double *)py_frequencies.data();
triplets = (int64_t(*)[3])py_triplets.data(); triplets = (int64_t (*)[3])py_triplets.data();
triplet_weights = (int64_t *)py_triplet_weights.data(); triplet_weights = (int64_t *)py_triplet_weights.data();
num_frequency_points = (int64_t)py_g.shape(2); num_frequency_points = (int64_t)py_g.shape(2);
ph3py_get_imag_self_energy_at_bands_with_g( ph3py_get_imag_self_energy_at_bands_with_g(
gamma, fc3_normal_squared, frequencies, triplets, triplet_weights, g, gamma, fc3_normal_squared, frequencies, triplets, triplet_weights, g,
g_zero, temperature, cutoff_frequency, num_frequency_points, g_zero, temperature_THz, cutoff_frequency, num_frequency_points,
frequency_point_index); frequency_point_index);
free(fc3_normal_squared); free(fc3_normal_squared);
@ -312,7 +312,7 @@ void py_get_detailed_imag_self_energy_with_g(
nb::ndarray<> py_gamma_U, nb::ndarray<> py_fc3_normal_squared, nb::ndarray<> py_gamma_U, nb::ndarray<> py_fc3_normal_squared,
nb::ndarray<> py_triplets, nb::ndarray<> py_triplet_weights, nb::ndarray<> py_triplets, nb::ndarray<> py_triplet_weights,
nb::ndarray<> py_bz_grid_addresses, nb::ndarray<> py_frequencies, nb::ndarray<> py_bz_grid_addresses, nb::ndarray<> py_frequencies,
double temperature, nb::ndarray<> py_g, nb::ndarray<> py_g_zero, double temperature_THz, nb::ndarray<> py_g, nb::ndarray<> py_g_zero,
double cutoff_frequency) { double cutoff_frequency) {
Darray *fc3_normal_squared; Darray *fc3_normal_squared;
double *gamma_detail; double *gamma_detail;
@ -321,9 +321,9 @@ void py_get_detailed_imag_self_energy_with_g(
double *g; double *g;
char *g_zero; char *g_zero;
double *frequencies; double *frequencies;
int64_t(*triplets)[3]; int64_t (*triplets)[3];
int64_t *triplet_weights; int64_t *triplet_weights;
int64_t(*bz_grid_addresses)[3]; int64_t (*bz_grid_addresses)[3];
fc3_normal_squared = convert_to_darray(py_fc3_normal_squared); fc3_normal_squared = convert_to_darray(py_fc3_normal_squared);
gamma_detail = (double *)py_gamma_detail.data(); gamma_detail = (double *)py_gamma_detail.data();
@ -332,14 +332,14 @@ void py_get_detailed_imag_self_energy_with_g(
g = (double *)py_g.data(); g = (double *)py_g.data();
g_zero = (char *)py_g_zero.data(); g_zero = (char *)py_g_zero.data();
frequencies = (double *)py_frequencies.data(); frequencies = (double *)py_frequencies.data();
triplets = (int64_t(*)[3])py_triplets.data(); triplets = (int64_t (*)[3])py_triplets.data();
triplet_weights = (int64_t *)py_triplet_weights.data(); triplet_weights = (int64_t *)py_triplet_weights.data();
bz_grid_addresses = (int64_t(*)[3])py_bz_grid_addresses.data(); bz_grid_addresses = (int64_t (*)[3])py_bz_grid_addresses.data();
ph3py_get_detailed_imag_self_energy_at_bands_with_g( ph3py_get_detailed_imag_self_energy_at_bands_with_g(
gamma_detail, gamma_N, gamma_U, fc3_normal_squared, frequencies, gamma_detail, gamma_N, gamma_U, fc3_normal_squared, frequencies,
triplets, triplet_weights, bz_grid_addresses, g, g_zero, temperature, triplets, triplet_weights, bz_grid_addresses, g, g_zero,
cutoff_frequency); temperature_THz, cutoff_frequency);
free(fc3_normal_squared); free(fc3_normal_squared);
fc3_normal_squared = NULL; fc3_normal_squared = NULL;
@ -349,25 +349,25 @@ void py_get_real_self_energy_at_bands(
nb::ndarray<> py_shift, nb::ndarray<> py_fc3_normal_squared, nb::ndarray<> py_shift, nb::ndarray<> py_fc3_normal_squared,
nb::ndarray<> py_triplets, nb::ndarray<> py_triplet_weights, nb::ndarray<> py_triplets, nb::ndarray<> py_triplet_weights,
nb::ndarray<> py_frequencies, nb::ndarray<> py_band_indices, nb::ndarray<> py_frequencies, nb::ndarray<> py_band_indices,
double temperature, double epsilon, double unit_conversion_factor, double temperature_THz, double epsilon, double unit_conversion_factor,
double cutoff_frequency) { double cutoff_frequency) {
Darray *fc3_normal_squared; Darray *fc3_normal_squared;
double *shift; double *shift;
double *frequencies; double *frequencies;
int64_t *band_indices; int64_t *band_indices;
int64_t(*triplets)[3]; int64_t (*triplets)[3];
int64_t *triplet_weights; int64_t *triplet_weights;
fc3_normal_squared = convert_to_darray(py_fc3_normal_squared); fc3_normal_squared = convert_to_darray(py_fc3_normal_squared);
shift = (double *)py_shift.data(); shift = (double *)py_shift.data();
frequencies = (double *)py_frequencies.data(); frequencies = (double *)py_frequencies.data();
band_indices = (int64_t *)py_band_indices.data(); band_indices = (int64_t *)py_band_indices.data();
triplets = (int64_t(*)[3])py_triplets.data(); triplets = (int64_t (*)[3])py_triplets.data();
triplet_weights = (int64_t *)py_triplet_weights.data(); triplet_weights = (int64_t *)py_triplet_weights.data();
ph3py_get_real_self_energy_at_bands( ph3py_get_real_self_energy_at_bands(
shift, fc3_normal_squared, band_indices, frequencies, triplets, shift, fc3_normal_squared, band_indices, frequencies, triplets,
triplet_weights, epsilon, temperature, unit_conversion_factor, triplet_weights, epsilon, temperature_THz, unit_conversion_factor,
cutoff_frequency); cutoff_frequency);
free(fc3_normal_squared); free(fc3_normal_squared);
@ -378,26 +378,26 @@ void py_get_real_self_energy_at_frequency_point(
nb::ndarray<> py_shift, double frequency_point, nb::ndarray<> py_shift, double frequency_point,
nb::ndarray<> py_fc3_normal_squared, nb::ndarray<> py_triplets, nb::ndarray<> py_fc3_normal_squared, nb::ndarray<> py_triplets,
nb::ndarray<> py_triplet_weights, nb::ndarray<> py_frequencies, nb::ndarray<> py_triplet_weights, nb::ndarray<> py_frequencies,
nb::ndarray<> py_band_indices, double temperature, double epsilon, nb::ndarray<> py_band_indices, double temperature_THz, double epsilon,
double unit_conversion_factor, double cutoff_frequency) { double unit_conversion_factor, double cutoff_frequency) {
Darray *fc3_normal_squared; Darray *fc3_normal_squared;
double *shift; double *shift;
double *frequencies; double *frequencies;
int64_t *band_indices; int64_t *band_indices;
int64_t(*triplets)[3]; int64_t (*triplets)[3];
int64_t *triplet_weights; int64_t *triplet_weights;
fc3_normal_squared = convert_to_darray(py_fc3_normal_squared); fc3_normal_squared = convert_to_darray(py_fc3_normal_squared);
shift = (double *)py_shift.data(); shift = (double *)py_shift.data();
frequencies = (double *)py_frequencies.data(); frequencies = (double *)py_frequencies.data();
band_indices = (int64_t *)py_band_indices.data(); band_indices = (int64_t *)py_band_indices.data();
triplets = (int64_t(*)[3])py_triplets.data(); triplets = (int64_t (*)[3])py_triplets.data();
triplet_weights = (int64_t *)py_triplet_weights.data(); triplet_weights = (int64_t *)py_triplet_weights.data();
ph3py_get_real_self_energy_at_frequency_point( ph3py_get_real_self_energy_at_frequency_point(
shift, frequency_point, fc3_normal_squared, band_indices, frequencies, shift, frequency_point, fc3_normal_squared, band_indices, frequencies,
triplets, triplet_weights, epsilon, temperature, unit_conversion_factor, triplets, triplet_weights, epsilon, temperature_THz,
cutoff_frequency); unit_conversion_factor, cutoff_frequency);
free(fc3_normal_squared); free(fc3_normal_squared);
fc3_normal_squared = NULL; fc3_normal_squared = NULL;
@ -408,13 +408,13 @@ void py_get_collision_matrix(
nb::ndarray<> py_frequencies, nb::ndarray<> py_g, nb::ndarray<> py_triplets, nb::ndarray<> py_frequencies, nb::ndarray<> py_g, nb::ndarray<> py_triplets,
nb::ndarray<> py_triplets_map, nb::ndarray<> py_map_q, nb::ndarray<> py_triplets_map, nb::ndarray<> py_map_q,
nb::ndarray<> py_rotated_grid_points, nb::ndarray<> py_rotations_cartesian, nb::ndarray<> py_rotated_grid_points, nb::ndarray<> py_rotations_cartesian,
double temperature, double unit_conversion_factor, double temperature_THz, double unit_conversion_factor,
double cutoff_frequency) { double cutoff_frequency) {
Darray *fc3_normal_squared; Darray *fc3_normal_squared;
double *collision_matrix; double *collision_matrix;
double *g; double *g;
double *frequencies; double *frequencies;
int64_t(*triplets)[3]; int64_t (*triplets)[3];
int64_t *triplets_map; int64_t *triplets_map;
int64_t *map_q; int64_t *map_q;
int64_t *rotated_grid_points; int64_t *rotated_grid_points;
@ -425,7 +425,7 @@ void py_get_collision_matrix(
collision_matrix = (double *)py_collision_matrix.data(); collision_matrix = (double *)py_collision_matrix.data();
g = (double *)py_g.data(); g = (double *)py_g.data();
frequencies = (double *)py_frequencies.data(); frequencies = (double *)py_frequencies.data();
triplets = (int64_t(*)[3])py_triplets.data(); triplets = (int64_t (*)[3])py_triplets.data();
triplets_map = (int64_t *)py_triplets_map.data(); triplets_map = (int64_t *)py_triplets_map.data();
num_gp = (int64_t)py_triplets_map.shape(0); num_gp = (int64_t)py_triplets_map.shape(0);
map_q = (int64_t *)py_map_q.data(); map_q = (int64_t *)py_map_q.data();
@ -440,7 +440,7 @@ void py_get_collision_matrix(
ph3py_get_collision_matrix(collision_matrix, fc3_normal_squared, ph3py_get_collision_matrix(collision_matrix, fc3_normal_squared,
frequencies, triplets, triplets_map, map_q, frequencies, triplets, triplets_map, map_q,
rotated_grid_points, rotations_cartesian, g, rotated_grid_points, rotations_cartesian, g,
num_ir_gp, num_gp, num_rot, temperature, num_ir_gp, num_gp, num_rot, temperature_THz,
unit_conversion_factor, cutoff_frequency); unit_conversion_factor, cutoff_frequency);
free(fc3_normal_squared); free(fc3_normal_squared);
@ -450,13 +450,14 @@ void py_get_collision_matrix(
void py_get_reducible_collision_matrix( void py_get_reducible_collision_matrix(
nb::ndarray<> py_collision_matrix, nb::ndarray<> py_fc3_normal_squared, nb::ndarray<> py_collision_matrix, nb::ndarray<> py_fc3_normal_squared,
nb::ndarray<> py_frequencies, nb::ndarray<> py_g, nb::ndarray<> py_triplets, nb::ndarray<> py_frequencies, nb::ndarray<> py_g, nb::ndarray<> py_triplets,
nb::ndarray<> py_triplets_map, nb::ndarray<> py_map_q, double temperature, nb::ndarray<> py_triplets_map, nb::ndarray<> py_map_q,
double unit_conversion_factor, double cutoff_frequency) { double temperature_THz, double unit_conversion_factor,
double cutoff_frequency) {
Darray *fc3_normal_squared; Darray *fc3_normal_squared;
double *collision_matrix; double *collision_matrix;
double *g; double *g;
double *frequencies; double *frequencies;
int64_t(*triplets)[3]; int64_t (*triplets)[3];
int64_t *triplets_map; int64_t *triplets_map;
int64_t num_gp; int64_t num_gp;
int64_t *map_q; int64_t *map_q;
@ -465,14 +466,14 @@ void py_get_reducible_collision_matrix(
collision_matrix = (double *)py_collision_matrix.data(); collision_matrix = (double *)py_collision_matrix.data();
g = (double *)py_g.data(); g = (double *)py_g.data();
frequencies = (double *)py_frequencies.data(); frequencies = (double *)py_frequencies.data();
triplets = (int64_t(*)[3])py_triplets.data(); triplets = (int64_t (*)[3])py_triplets.data();
triplets_map = (int64_t *)py_triplets_map.data(); triplets_map = (int64_t *)py_triplets_map.data();
num_gp = (int64_t)py_triplets_map.shape(0); num_gp = (int64_t)py_triplets_map.shape(0);
map_q = (int64_t *)py_map_q.data(); map_q = (int64_t *)py_map_q.data();
ph3py_get_reducible_collision_matrix( ph3py_get_reducible_collision_matrix(
collision_matrix, fc3_normal_squared, frequencies, triplets, collision_matrix, fc3_normal_squared, frequencies, triplets,
triplets_map, map_q, g, num_gp, temperature, unit_conversion_factor, triplets_map, map_q, g, num_gp, temperature_THz, unit_conversion_factor,
cutoff_frequency); cutoff_frequency);
free(fc3_normal_squared); free(fc3_normal_squared);
@ -544,21 +545,21 @@ void py_rotate_delta_fc2s(nb::ndarray<> py_fc3, nb::ndarray<> py_delta_fc2s,
nb::ndarray<> py_inv_U, nb::ndarray<> py_inv_U,
nb::ndarray<> py_site_sym_cart, nb::ndarray<> py_site_sym_cart,
nb::ndarray<> py_rot_map_syms) { nb::ndarray<> py_rot_map_syms) {
double(*fc3)[3][3][3]; double (*fc3)[3][3][3];
double(*delta_fc2s)[3][3]; double (*delta_fc2s)[3][3];
double *inv_U; double *inv_U;
double(*site_sym_cart)[3][3]; double (*site_sym_cart)[3][3];
int64_t *rot_map_syms; int64_t *rot_map_syms;
int64_t num_atom, num_disp, num_site_sym; int64_t num_atom, num_disp, num_site_sym;
/* (num_atom, num_atom, 3, 3, 3) */ /* (num_atom, num_atom, 3, 3, 3) */
fc3 = (double(*)[3][3][3])py_fc3.data(); fc3 = (double (*)[3][3][3])py_fc3.data();
/* (n_u1, num_atom, num_atom, 3, 3) */ /* (n_u1, num_atom, num_atom, 3, 3) */
delta_fc2s = (double(*)[3][3])py_delta_fc2s.data(); delta_fc2s = (double (*)[3][3])py_delta_fc2s.data();
/* (3, n_u1 * n_sym) */ /* (3, n_u1 * n_sym) */
inv_U = (double *)py_inv_U.data(); inv_U = (double *)py_inv_U.data();
/* (n_sym, 3, 3) */ /* (n_sym, 3, 3) */
site_sym_cart = (double(*)[3][3])py_site_sym_cart.data(); site_sym_cart = (double (*)[3][3])py_site_sym_cart.data();
/* (n_sym, natom) */ /* (n_sym, natom) */
rot_map_syms = (int64_t *)py_rot_map_syms.data(); rot_map_syms = (int64_t *)py_rot_map_syms.data();
@ -695,11 +696,11 @@ void py_transpose_compact_fc3(nb::ndarray<> py_fc3,
void py_get_thm_relative_grid_address(nb::ndarray<> py_relative_grid_address, void py_get_thm_relative_grid_address(nb::ndarray<> py_relative_grid_address,
nb::ndarray<> py_reciprocal_lattice_py) { nb::ndarray<> py_reciprocal_lattice_py) {
int64_t(*relative_grid_address)[4][3]; int64_t (*relative_grid_address)[4][3];
double(*reciprocal_lattice)[3]; double (*reciprocal_lattice)[3];
relative_grid_address = (int64_t(*)[4][3])py_relative_grid_address.data(); relative_grid_address = (int64_t (*)[4][3])py_relative_grid_address.data();
reciprocal_lattice = (double(*)[3])py_reciprocal_lattice_py.data(); reciprocal_lattice = (double (*)[3])py_reciprocal_lattice_py.data();
ph3py_get_relative_grid_address(relative_grid_address, reciprocal_lattice); ph3py_get_relative_grid_address(relative_grid_address, reciprocal_lattice);
} }
@ -714,18 +715,18 @@ void py_get_neighboring_grid_points(nb::ndarray<> py_relative_grid_points,
int64_t *relative_grid_points; int64_t *relative_grid_points;
int64_t *grid_points; int64_t *grid_points;
int64_t num_grid_points, num_relative_grid_address; int64_t num_grid_points, num_relative_grid_address;
int64_t(*relative_grid_address)[3]; int64_t (*relative_grid_address)[3];
int64_t *D_diag; int64_t *D_diag;
int64_t(*bz_grid_address)[3]; int64_t (*bz_grid_address)[3];
int64_t *bz_map; int64_t *bz_map;
relative_grid_points = (int64_t *)py_relative_grid_points.data(); relative_grid_points = (int64_t *)py_relative_grid_points.data();
grid_points = (int64_t *)py_grid_points.data(); grid_points = (int64_t *)py_grid_points.data();
num_grid_points = (int64_t)py_grid_points.shape(0); num_grid_points = (int64_t)py_grid_points.shape(0);
relative_grid_address = (int64_t(*)[3])py_relative_grid_address.data(); relative_grid_address = (int64_t (*)[3])py_relative_grid_address.data();
num_relative_grid_address = (int64_t)py_relative_grid_address.shape(0); num_relative_grid_address = (int64_t)py_relative_grid_address.shape(0);
D_diag = (int64_t *)py_D_diag.data(); D_diag = (int64_t *)py_D_diag.data();
bz_grid_address = (int64_t(*)[3])py_bz_grid_address.data(); bz_grid_address = (int64_t (*)[3])py_bz_grid_address.data();
bz_map = (int64_t *)py_bz_map.data(); bz_map = (int64_t *)py_bz_map.data();
ph3py_get_neighboring_gird_points( ph3py_get_neighboring_gird_points(
@ -743,10 +744,10 @@ void py_get_thm_integration_weights_at_grid_points(
double *iw; double *iw;
double *frequency_points; double *frequency_points;
int64_t num_frequency_points, num_band, num_gp; int64_t num_frequency_points, num_band, num_gp;
int64_t(*relative_grid_address)[4][3]; int64_t (*relative_grid_address)[4][3];
int64_t *D_diag; int64_t *D_diag;
int64_t *grid_points; int64_t *grid_points;
int64_t(*bz_grid_address)[3]; int64_t (*bz_grid_address)[3];
int64_t *bz_map; int64_t *bz_map;
int64_t *gp2irgp_map; int64_t *gp2irgp_map;
double *frequencies; double *frequencies;
@ -754,11 +755,11 @@ void py_get_thm_integration_weights_at_grid_points(
iw = (double *)py_iw.data(); iw = (double *)py_iw.data();
frequency_points = (double *)py_frequency_points.data(); frequency_points = (double *)py_frequency_points.data();
num_frequency_points = (int64_t)py_frequency_points.shape(0); num_frequency_points = (int64_t)py_frequency_points.shape(0);
relative_grid_address = (int64_t(*)[4][3])py_relative_grid_address.data(); relative_grid_address = (int64_t (*)[4][3])py_relative_grid_address.data();
D_diag = (int64_t *)py_D_diag.data(); D_diag = (int64_t *)py_D_diag.data();
grid_points = (int64_t *)py_grid_points.data(); grid_points = (int64_t *)py_grid_points.data();
num_gp = (int64_t)py_grid_points.shape(0); num_gp = (int64_t)py_grid_points.shape(0);
bz_grid_address = (int64_t(*)[3])py_bz_grid_address.data(); bz_grid_address = (int64_t (*)[3])py_bz_grid_address.data();
bz_map = (int64_t *)py_bz_map.data(); bz_map = (int64_t *)py_bz_map.data();
gp2irgp_map = (int64_t *)py_gp2irgp_map.data(); gp2irgp_map = (int64_t *)py_gp2irgp_map.data();
frequencies = (double *)py_frequencies.data(); frequencies = (double *)py_frequencies.data();
@ -777,14 +778,14 @@ int64_t py_tpl_get_triplets_reciprocal_mesh_at_q(
int64_t *map_triplets; int64_t *map_triplets;
int64_t *map_q; int64_t *map_q;
int64_t *D_diag; int64_t *D_diag;
int64_t(*rot)[3][3]; int64_t (*rot)[3][3];
int64_t num_rot; int64_t num_rot;
int64_t num_ir; int64_t num_ir;
map_triplets = (int64_t *)py_map_triplets.data(); map_triplets = (int64_t *)py_map_triplets.data();
map_q = (int64_t *)py_map_q.data(); map_q = (int64_t *)py_map_q.data();
D_diag = (int64_t *)py_D_diag.data(); D_diag = (int64_t *)py_D_diag.data();
rot = (int64_t(*)[3][3])py_rotations.data(); rot = (int64_t (*)[3][3])py_rotations.data();
num_rot = (int64_t)py_rotations.shape(0); num_rot = (int64_t)py_rotations.shape(0);
num_ir = ph3py_get_triplets_reciprocal_mesh_at_q( num_ir = ph3py_get_triplets_reciprocal_mesh_at_q(
@ -801,22 +802,22 @@ int64_t py_tpl_get_BZ_triplets_at_q(nb::ndarray<> py_triplets,
nb::ndarray<> py_map_triplets, nb::ndarray<> py_map_triplets,
nb::ndarray<> py_D_diag, nb::ndarray<> py_Q, nb::ndarray<> py_D_diag, nb::ndarray<> py_Q,
int64_t bz_grid_type) { int64_t bz_grid_type) {
int64_t(*triplets)[3]; int64_t (*triplets)[3];
int64_t(*bz_grid_address)[3]; int64_t (*bz_grid_address)[3];
int64_t *bz_map; int64_t *bz_map;
int64_t *map_triplets; int64_t *map_triplets;
int64_t num_map_triplets; int64_t num_map_triplets;
int64_t *D_diag; int64_t *D_diag;
int64_t(*Q)[3]; int64_t (*Q)[3];
int64_t num_ir; int64_t num_ir;
triplets = (int64_t(*)[3])py_triplets.data(); triplets = (int64_t (*)[3])py_triplets.data();
bz_grid_address = (int64_t(*)[3])py_bz_grid_address.data(); bz_grid_address = (int64_t (*)[3])py_bz_grid_address.data();
bz_map = (int64_t *)py_bz_map.data(); bz_map = (int64_t *)py_bz_map.data();
map_triplets = (int64_t *)py_map_triplets.data(); map_triplets = (int64_t *)py_map_triplets.data();
num_map_triplets = (int64_t)py_map_triplets.shape(0); num_map_triplets = (int64_t)py_map_triplets.shape(0);
D_diag = (int64_t *)py_D_diag.data(); D_diag = (int64_t *)py_D_diag.data();
Q = (int64_t(*)[3])py_Q.data(); Q = (int64_t (*)[3])py_Q.data();
num_ir = ph3py_get_BZ_triplets_at_q(triplets, grid_point, bz_grid_address, num_ir = ph3py_get_BZ_triplets_at_q(triplets, grid_point, bz_grid_address,
bz_map, map_triplets, num_map_triplets, bz_map, map_triplets, num_map_triplets,
@ -835,10 +836,10 @@ void py_get_triplets_integration_weights(
double *iw; double *iw;
char *iw_zero; char *iw_zero;
double *frequency_points; double *frequency_points;
int64_t(*relative_grid_address)[4][3]; int64_t (*relative_grid_address)[4][3];
int64_t *D_diag; int64_t *D_diag;
int64_t(*triplets)[3]; int64_t (*triplets)[3];
int64_t(*bz_grid_addresses)[3]; int64_t (*bz_grid_addresses)[3];
int64_t *bz_map; int64_t *bz_map;
double *frequencies1, *frequencies2; double *frequencies1, *frequencies2;
int64_t num_band0, num_band1, num_band2, num_triplets; int64_t num_band0, num_band1, num_band2, num_triplets;
@ -847,11 +848,11 @@ void py_get_triplets_integration_weights(
iw_zero = (char *)py_iw_zero.data(); iw_zero = (char *)py_iw_zero.data();
frequency_points = (double *)py_frequency_points.data(); frequency_points = (double *)py_frequency_points.data();
num_band0 = (int64_t)py_frequency_points.shape(0); num_band0 = (int64_t)py_frequency_points.shape(0);
relative_grid_address = (int64_t(*)[4][3])py_relative_grid_address.data(); relative_grid_address = (int64_t (*)[4][3])py_relative_grid_address.data();
D_diag = (int64_t *)py_D_diag.data(); D_diag = (int64_t *)py_D_diag.data();
triplets = (int64_t(*)[3])py_triplets.data(); triplets = (int64_t (*)[3])py_triplets.data();
num_triplets = (int64_t)py_triplets.shape(0); num_triplets = (int64_t)py_triplets.shape(0);
bz_grid_addresses = (int64_t(*)[3])py_bz_grid_addresses.data(); bz_grid_addresses = (int64_t (*)[3])py_bz_grid_addresses.data();
bz_map = (int64_t *)py_bz_map.data(); bz_map = (int64_t *)py_bz_map.data();
frequencies1 = (double *)py_frequencies1.data(); frequencies1 = (double *)py_frequencies1.data();
frequencies2 = (double *)py_frequencies2.data(); frequencies2 = (double *)py_frequencies2.data();
@ -871,7 +872,7 @@ void py_get_triplets_integration_weights_with_sigma(
double *iw; double *iw;
char *iw_zero; char *iw_zero;
double *frequency_points; double *frequency_points;
int64_t(*triplets)[3]; int64_t (*triplets)[3];
double *frequencies; double *frequencies;
int64_t num_band0, num_band, num_iw, num_triplets; int64_t num_band0, num_band, num_iw, num_triplets;
@ -879,7 +880,7 @@ void py_get_triplets_integration_weights_with_sigma(
iw_zero = (char *)py_iw_zero.data(); iw_zero = (char *)py_iw_zero.data();
frequency_points = (double *)py_frequency_points.data(); frequency_points = (double *)py_frequency_points.data();
num_band0 = (int64_t)py_frequency_points.shape(0); num_band0 = (int64_t)py_frequency_points.shape(0);
triplets = (int64_t(*)[3])py_triplets.data(); triplets = (int64_t (*)[3])py_triplets.data();
num_triplets = (int64_t)py_triplets.shape(0); num_triplets = (int64_t)py_triplets.shape(0);
frequencies = (double *)py_frequencies.data(); frequencies = (double *)py_frequencies.data();
num_band = (int64_t)py_frequencies.shape(1); num_band = (int64_t)py_frequencies.shape(1);

62
c/collision_matrix.c
View File

@ -49,7 +49,7 @@ static void get_collision_matrix(
const int64_t num_gp, const int64_t *map_q, const int64_t *rot_grid_points, const int64_t num_gp, const int64_t *map_q, const int64_t *rot_grid_points,
const int64_t num_ir_gp, const int64_t num_rot, const int64_t num_ir_gp, const int64_t num_rot,
const double *rotations_cartesian, const double *g, const double *rotations_cartesian, const double *g,
const double temperature, const double unit_conversion_factor, const double temperature_THz, const double unit_conversion_factor,
const double cutoff_frequency); const double cutoff_frequency);
static void get_collision_matrix_at_gp( static void get_collision_matrix_at_gp(
double *collision_matrix, const double *fc3_normal_squared, double *collision_matrix, const double *fc3_normal_squared,
@ -58,25 +58,25 @@ static void get_collision_matrix_at_gp(
const int64_t *map_q, const int64_t *rot_grid_points, const int64_t *map_q, const int64_t *rot_grid_points,
const int64_t num_ir_gp, const int64_t num_rot, const int64_t num_ir_gp, const int64_t num_rot,
const double *rotations_cartesian, const double *g, const double *rotations_cartesian, const double *g,
const double temperature, const double unit_conversion_factor, const double temperature_THz, const double unit_conversion_factor,
const double cutoff_frequency, const int64_t *gp2tp_map, const int64_t i); const double cutoff_frequency, const int64_t *gp2tp_map, const int64_t i);
static void get_reducible_collision_matrix( static void get_reducible_collision_matrix(
double *collision_matrix, const double *fc3_normal_squared, double *collision_matrix, const double *fc3_normal_squared,
const int64_t num_band0, const int64_t num_band, const double *frequencies, const int64_t num_band0, const int64_t num_band, const double *frequencies,
const int64_t (*triplets)[3], const int64_t *triplets_map, const int64_t (*triplets)[3], const int64_t *triplets_map,
const int64_t num_gp, const int64_t *map_q, const double *g, const int64_t num_gp, const int64_t *map_q, const double *g,
const double temperature, const double unit_conversion_factor, const double temperature_THz, const double unit_conversion_factor,
const double cutoff_frequency); const double cutoff_frequency);
static void get_reducible_collision_matrix_at_gp( static void get_reducible_collision_matrix_at_gp(
double *collision_matrix, const double *fc3_normal_squared, double *collision_matrix, const double *fc3_normal_squared,
const int64_t num_band0, const int64_t num_band, const double *frequencies, const int64_t num_band0, const int64_t num_band, const double *frequencies,
const int64_t (*triplets)[3], const int64_t *triplets_map, const int64_t (*triplets)[3], const int64_t *triplets_map,
const int64_t num_gp, const int64_t *map_q, const double *g, const int64_t num_gp, const int64_t *map_q, const double *g,
const double temperature, const double unit_conversion_factor, const double temperature_THz, const double unit_conversion_factor,
const double cutoff_frequency, const int64_t *gp2tp_map, const int64_t i); const double cutoff_frequency, const int64_t *gp2tp_map, const int64_t i);
static int64_t get_inv_sinh(double *inv_sinh, const int64_t gp, static int64_t get_inv_sinh(double *inv_sinh, const int64_t gp,
const double temperature, const double *frequencies, const double temperature_THz,
const int64_t triplet[3], const double *frequencies, const int64_t triplet[3],
const int64_t *triplets_map, const int64_t *map_q, const int64_t *triplets_map, const int64_t *map_q,
const int64_t num_band, const int64_t num_band,
const double cutoff_frequency); const double cutoff_frequency);
@ -89,7 +89,7 @@ void col_get_collision_matrix(
const int64_t *triplets_map, const int64_t *map_q, const int64_t *triplets_map, const int64_t *map_q,
const int64_t *rot_grid_points, const double *rotations_cartesian, const int64_t *rot_grid_points, const double *rotations_cartesian,
const double *g, const int64_t num_ir_gp, const int64_t num_gp, const double *g, const int64_t num_ir_gp, const int64_t num_gp,
const int64_t num_rot, const double temperature, const int64_t num_rot, const double temperature_THz,
const double unit_conversion_factor, const double cutoff_frequency) { const double unit_conversion_factor, const double cutoff_frequency) {
int64_t num_triplets, num_band0, num_band; int64_t num_triplets, num_band0, num_band;
@ -97,19 +97,19 @@ void col_get_collision_matrix(
num_band0 = fc3_normal_squared->dims[1]; num_band0 = fc3_normal_squared->dims[1];
num_band = fc3_normal_squared->dims[2]; num_band = fc3_normal_squared->dims[2];
get_collision_matrix(collision_matrix, fc3_normal_squared->data, num_band0, get_collision_matrix(
num_band, frequencies, triplets, triplets_map, num_gp, collision_matrix, fc3_normal_squared->data, num_band0, num_band,
map_q, rot_grid_points, num_ir_gp, num_rot, frequencies, triplets, triplets_map, num_gp, map_q, rot_grid_points,
rotations_cartesian, num_ir_gp, num_rot, rotations_cartesian,
g + 2 * num_triplets * num_band0 * num_band * num_band, g + 2 * num_triplets * num_band0 * num_band * num_band, temperature_THz,
temperature, unit_conversion_factor, cutoff_frequency); unit_conversion_factor, cutoff_frequency);
} }
void col_get_reducible_collision_matrix( void col_get_reducible_collision_matrix(
double *collision_matrix, const Darray *fc3_normal_squared, double *collision_matrix, const Darray *fc3_normal_squared,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplets_map, const int64_t *map_q, const double *g, const int64_t *triplets_map, const int64_t *map_q, const double *g,
const int64_t num_gp, const double temperature, const int64_t num_gp, const double temperature_THz,
const double unit_conversion_factor, const double cutoff_frequency) { const double unit_conversion_factor, const double cutoff_frequency) {
int64_t num_triplets, num_band, num_band0; int64_t num_triplets, num_band, num_band0;
@ -120,7 +120,7 @@ void col_get_reducible_collision_matrix(
get_reducible_collision_matrix( get_reducible_collision_matrix(
collision_matrix, fc3_normal_squared->data, num_band0, num_band, collision_matrix, fc3_normal_squared->data, num_band0, num_band,
frequencies, triplets, triplets_map, num_gp, map_q, frequencies, triplets, triplets_map, num_gp, map_q,
g + 2 * num_triplets * num_band0 * num_band * num_band, temperature, g + 2 * num_triplets * num_band0 * num_band * num_band, temperature_THz,
unit_conversion_factor, cutoff_frequency); unit_conversion_factor, cutoff_frequency);
} }
@ -131,7 +131,7 @@ static void get_collision_matrix(
const int64_t num_gp, const int64_t *map_q, const int64_t *rot_grid_points, const int64_t num_gp, const int64_t *map_q, const int64_t *rot_grid_points,
const int64_t num_ir_gp, const int64_t num_rot, const int64_t num_ir_gp, const int64_t num_rot,
const double *rotations_cartesian, const double *g, const double *rotations_cartesian, const double *g,
const double temperature, const double unit_conversion_factor, const double temperature_THz, const double unit_conversion_factor,
const double cutoff_frequency) { const double cutoff_frequency) {
int64_t i; int64_t i;
int64_t *gp2tp_map; int64_t *gp2tp_map;
@ -145,7 +145,7 @@ static void get_collision_matrix(
get_collision_matrix_at_gp( get_collision_matrix_at_gp(
collision_matrix, fc3_normal_squared, num_band0, num_band, collision_matrix, fc3_normal_squared, num_band0, num_band,
frequencies, triplets, triplets_map, map_q, rot_grid_points, frequencies, triplets, triplets_map, map_q, rot_grid_points,
num_ir_gp, num_rot, rotations_cartesian, g, temperature, num_ir_gp, num_rot, rotations_cartesian, g, temperature_THz,
unit_conversion_factor, cutoff_frequency, gp2tp_map, i); unit_conversion_factor, cutoff_frequency, gp2tp_map, i);
} }
@ -160,7 +160,7 @@ static void get_collision_matrix_at_gp(
const int64_t *map_q, const int64_t *rot_grid_points, const int64_t *map_q, const int64_t *rot_grid_points,
const int64_t num_ir_gp, const int64_t num_rot, const int64_t num_ir_gp, const int64_t num_rot,
const double *rotations_cartesian, const double *g, const double *rotations_cartesian, const double *g,
const double temperature, const double unit_conversion_factor, const double temperature_THz, const double unit_conversion_factor,
const double cutoff_frequency, const int64_t *gp2tp_map, const int64_t i) { const double cutoff_frequency, const int64_t *gp2tp_map, const int64_t i) {
int64_t j, k, l, m, n, ti, r_gp, swapped; int64_t j, k, l, m, n, ti, r_gp, swapped;
@ -171,9 +171,9 @@ static void get_collision_matrix_at_gp(
for (j = 0; j < num_rot; j++) { for (j = 0; j < num_rot; j++) {
r_gp = rot_grid_points[i * num_rot + j]; r_gp = rot_grid_points[i * num_rot + j];
ti = gp2tp_map[triplets_map[r_gp]]; ti = gp2tp_map[triplets_map[r_gp]];
swapped = swapped = get_inv_sinh(inv_sinh, r_gp, temperature_THz, frequencies,
get_inv_sinh(inv_sinh, r_gp, temperature, frequencies, triplets[ti], triplets[ti], triplets_map, map_q, num_band,
triplets_map, map_q, num_band, cutoff_frequency); cutoff_frequency);
for (k = 0; k < num_band0; k++) { for (k = 0; k < num_band0; k++) {
for (l = 0; l < num_band; l++) { for (l = 0; l < num_band; l++) {
@ -219,7 +219,7 @@ static void get_reducible_collision_matrix(
const int64_t num_band0, const int64_t num_band, const double *frequencies, const int64_t num_band0, const int64_t num_band, const double *frequencies,
const int64_t (*triplets)[3], const int64_t *triplets_map, const int64_t (*triplets)[3], const int64_t *triplets_map,
const int64_t num_gp, const int64_t *map_q, const double *g, const int64_t num_gp, const int64_t *map_q, const double *g,
const double temperature, const double unit_conversion_factor, const double temperature_THz, const double unit_conversion_factor,
const double cutoff_frequency) { const double cutoff_frequency) {
int64_t i; int64_t i;
int64_t *gp2tp_map; int64_t *gp2tp_map;
@ -232,8 +232,9 @@ static void get_reducible_collision_matrix(
for (i = 0; i < num_gp; i++) { for (i = 0; i < num_gp; i++) {
get_reducible_collision_matrix_at_gp( get_reducible_collision_matrix_at_gp(
collision_matrix, fc3_normal_squared, num_band0, num_band, collision_matrix, fc3_normal_squared, num_band0, num_band,
frequencies, triplets, triplets_map, num_gp, map_q, g, temperature, frequencies, triplets, triplets_map, num_gp, map_q, g,
unit_conversion_factor, cutoff_frequency, gp2tp_map, i); temperature_THz, unit_conversion_factor, cutoff_frequency,
gp2tp_map, i);
} }
free(gp2tp_map); free(gp2tp_map);
@ -245,7 +246,7 @@ static void get_reducible_collision_matrix_at_gp(
const int64_t num_band0, const int64_t num_band, const double *frequencies, const int64_t num_band0, const int64_t num_band, const double *frequencies,
const int64_t (*triplets)[3], const int64_t *triplets_map, const int64_t (*triplets)[3], const int64_t *triplets_map,
const int64_t num_gp, const int64_t *map_q, const double *g, const int64_t num_gp, const int64_t *map_q, const double *g,
const double temperature, const double unit_conversion_factor, const double temperature_THz, const double unit_conversion_factor,
const double cutoff_frequency, const int64_t *gp2tp_map, const int64_t i) { const double cutoff_frequency, const int64_t *gp2tp_map, const int64_t i) {
int64_t j, k, l, ti, swapped; int64_t j, k, l, ti, swapped;
double collision; double collision;
@ -253,8 +254,9 @@ static void get_reducible_collision_matrix_at_gp(
inv_sinh = (double *)malloc(sizeof(double) * num_band); inv_sinh = (double *)malloc(sizeof(double) * num_band);
ti = gp2tp_map[triplets_map[i]]; ti = gp2tp_map[triplets_map[i]];
swapped = get_inv_sinh(inv_sinh, i, temperature, frequencies, triplets[ti], swapped =
triplets_map, map_q, num_band, cutoff_frequency); get_inv_sinh(inv_sinh, i, temperature_THz, frequencies, triplets[ti],
triplets_map, map_q, num_band, cutoff_frequency);
for (j = 0; j < num_band0; j++) { for (j = 0; j < num_band0; j++) {
for (k = 0; k < num_band; k++) { for (k = 0; k < num_band; k++) {
@ -288,8 +290,8 @@ static void get_reducible_collision_matrix_at_gp(
} }
static int64_t get_inv_sinh(double *inv_sinh, const int64_t gp, static int64_t get_inv_sinh(double *inv_sinh, const int64_t gp,
const double temperature, const double *frequencies, const double temperature_THz,
const int64_t triplet[3], const double *frequencies, const int64_t triplet[3],
const int64_t *triplets_map, const int64_t *map_q, const int64_t *triplets_map, const int64_t *map_q,
const int64_t num_band, const int64_t num_band,
const double cutoff_frequency) { const double cutoff_frequency) {
@ -310,7 +312,7 @@ static int64_t get_inv_sinh(double *inv_sinh, const int64_t gp,
for (i = 0; i < num_band; i++) { for (i = 0; i < num_band; i++) {
f = frequencies[gp2 * num_band + i]; f = frequencies[gp2 * num_band + i];
if (f > cutoff_frequency) { if (f > cutoff_frequency) {
inv_sinh[i] = funcs_inv_sinh_occupation(f, temperature); inv_sinh[i] = funcs_inv_sinh_occupation(f, temperature_THz);
} else { } else {
inv_sinh[i] = 0; inv_sinh[i] = 0;
} }

4
c/collision_matrix.h
View File

@ -45,13 +45,13 @@ void col_get_collision_matrix(
const int64_t *triplets_map, const int64_t *map_q, const int64_t *triplets_map, const int64_t *map_q,
const int64_t *rot_grid_points, const double *rotations_cartesian, const int64_t *rot_grid_points, const double *rotations_cartesian,
const double *g, const int64_t num_ir_gp, const int64_t num_gp, const double *g, const int64_t num_ir_gp, const int64_t num_gp,
const int64_t num_rot, const double temperature, const int64_t num_rot, const double temperature_THz,
const double unit_conversion_factor, const double cutoff_frequency); const double unit_conversion_factor, const double cutoff_frequency);
void col_get_reducible_collision_matrix( void col_get_reducible_collision_matrix(
double *collision_matrix, const Darray *fc3_normal_squared, double *collision_matrix, const Darray *fc3_normal_squared,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplets_map, const int64_t *map_q, const double *g, const int64_t *triplets_map, const int64_t *map_q, const double *g,
const int64_t num_gp, const double temperature, const int64_t num_gp, const double temperature_THz,
const double unit_conversion_factor, const double cutoff_frequency); const double unit_conversion_factor, const double cutoff_frequency);
#endif #endif

9
c/funcs.c
View File

@ -38,17 +38,16 @@
#include "phonoc_const.h" #include "phonoc_const.h"
#define THZTOEVPARKB 47.992398658977166
#define INVSQRT2PI 0.3989422804014327 #define INVSQRT2PI 0.3989422804014327
double funcs_bose_einstein(const double x, const double t) { double funcs_bose_einstein(const double x, const double temperature_THz) {
return 1.0 / (exp(THZTOEVPARKB * x / t) - 1); return 1.0 / (exp(x / temperature_THz) - 1);
} }
double funcs_gaussian(const double x, const double sigma) { double funcs_gaussian(const double x, const double sigma) {
return INVSQRT2PI / sigma * exp(-x * x / 2 / sigma / sigma); return INVSQRT2PI / sigma * exp(-x * x / 2 / sigma / sigma);
} }
double funcs_inv_sinh_occupation(const double x, const double t) { double funcs_inv_sinh_occupation(const double x, const double temperature_THz) {
return 1.0 / sinh(x * THZTOEVPARKB / 2 / t); return 1.0 / sinh(x / 2 / temperature_THz);
} }

36
c/imag_self_energy_with_g.c
View File

@ -53,7 +53,7 @@ static void detailed_imag_self_energy_at_triplet(
const int64_t num_band0, const int64_t num_band, const int64_t num_band0, const int64_t num_band,
const double *fc3_normal_squared, const double *frequencies, const double *fc3_normal_squared, const double *frequencies,
const int64_t triplet[3], const double *g1, const double *g2_3, const int64_t triplet[3], const double *g1, const double *g2_3,
const char *g_zero, const double *temperatures, const int64_t num_temps, const char *g_zero, const double *temperatures_THz, const int64_t num_temps,
const double cutoff_frequency); const double cutoff_frequency);
static double collect_detailed_imag_self_energy( static double collect_detailed_imag_self_energy(
double *imag_self_energy, const int64_t num_band, double *imag_self_energy, const int64_t num_band,
@ -72,11 +72,11 @@ void ise_get_imag_self_energy_with_g(
double *imag_self_energy, const Darray *fc3_normal_squared, double *imag_self_energy, const Darray *fc3_normal_squared,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplet_weights, const double *g, const char *g_zero, const int64_t *triplet_weights, const double *g, const char *g_zero,
const double temperature, const double cutoff_frequency, const double temperature_THz, const double cutoff_frequency,
const int64_t num_frequency_points, const int64_t frequency_point_index) { const int64_t num_frequency_points, const int64_t frequency_point_index) {
int64_t i, j, num_triplets, num_band0, num_band, num_band_prod; int64_t i, j, num_triplets, num_band0, num_band, num_band_prod;
int64_t num_g_pos, g_index_dims, g_index_shift; int64_t num_g_pos, g_index_dims, g_index_shift;
int64_t(*g_pos)[4]; int64_t (*g_pos)[4];
double *ise; double *ise;
int64_t at_a_frequency_point; int64_t at_a_frequency_point;
@ -118,7 +118,7 @@ void ise_get_imag_self_energy_with_g(
* ise_set_g_pos works for frequency points as bands. * ise_set_g_pos works for frequency points as bands.
* set_g_pos_frequency_point works for frequency sampling mode. * set_g_pos_frequency_point works for frequency sampling mode.
*/ */
g_pos = (int64_t(*)[4])malloc(sizeof(int64_t[4]) * num_band_prod); g_pos = (int64_t (*)[4])malloc(sizeof(int64_t[4]) * num_band_prod);
if (at_a_frequency_point) { if (at_a_frequency_point) {
num_g_pos = set_g_pos_frequency_point( num_g_pos = set_g_pos_frequency_point(
g_pos, num_band0, num_band, g_pos, num_band0, num_band,
@ -134,7 +134,7 @@ void ise_get_imag_self_energy_with_g(
triplets[i], triplet_weights[i], triplets[i], triplet_weights[i],
g + i * g_index_dims + g_index_shift, g + i * g_index_dims + g_index_shift,
g + (i + num_triplets) * g_index_dims + g_index_shift, g_pos, g + (i + num_triplets) * g_index_dims + g_index_shift, g_pos,
num_g_pos, &temperature, 1, cutoff_frequency, 0, num_g_pos, &temperature_THz, 1, cutoff_frequency, 0,
at_a_frequency_point); at_a_frequency_point);
free(g_pos); free(g_pos);
@ -160,7 +160,7 @@ void ise_get_detailed_imag_self_energy_with_g(
double *imag_self_energy_U, const Darray *fc3_normal_squared, double *imag_self_energy_U, const Darray *fc3_normal_squared,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplet_weights, const int64_t (*bz_grid_addresses)[3], const int64_t *triplet_weights, const int64_t (*bz_grid_addresses)[3],
const double *g, const char *g_zero, const double temperature, const double *g, const char *g_zero, const double temperature_THz,
const double cutoff_frequency) { const double cutoff_frequency) {
double *ise; double *ise;
int64_t i, j, num_triplets, num_band0, num_band, num_band_prod; int64_t i, j, num_triplets, num_band0, num_band, num_band_prod;
@ -187,7 +187,7 @@ void ise_get_detailed_imag_self_energy_with_g(
num_band0, num_band, fc3_normal_squared->data + i * num_band_prod, num_band0, num_band, fc3_normal_squared->data + i * num_band_prod,
frequencies, triplets[i], g + i * num_band_prod, frequencies, triplets[i], g + i * num_band_prod,
g + (i + num_triplets) * num_band_prod, g_zero + i * num_band_prod, g + (i + num_triplets) * num_band_prod, g_zero + i * num_band_prod,
&temperature, 1, cutoff_frequency); &temperature_THz, 1, cutoff_frequency);
} }
is_N = (int64_t *)malloc(sizeof(int64_t) * num_triplets); is_N = (int64_t *)malloc(sizeof(int64_t) * num_triplets);
@ -224,7 +224,7 @@ void ise_imag_self_energy_at_triplet(
const double *fc3_normal_squared, const double *frequencies, const double *fc3_normal_squared, const double *frequencies,
const int64_t triplet[3], const int64_t triplet_weight, const double *g1, const int64_t triplet[3], const int64_t triplet_weight, const double *g1,
const double *g2_3, const int64_t (*g_pos)[4], const int64_t num_g_pos, const double *g2_3, const int64_t (*g_pos)[4], const int64_t num_g_pos,
const double *temperatures, const int64_t num_temps, const double *temperatures_THz, const int64_t num_temps,
const double cutoff_frequency, const int64_t openmp_per_triplets, const double cutoff_frequency, const int64_t openmp_per_triplets,
const int64_t at_a_frequency_point) { const int64_t at_a_frequency_point) {
int64_t i, j; int64_t i, j;
@ -237,7 +237,7 @@ void ise_imag_self_energy_at_triplet(
for (i = 0; i < num_temps; i++) { for (i = 0; i < num_temps; i++) {
set_occupations(n1 + i * num_band, n2 + i * num_band, num_band, set_occupations(n1 + i * num_band, n2 + i * num_band, num_band,
temperatures[i], triplet, frequencies, temperatures_THz[i], triplet, frequencies,
cutoff_frequency); cutoff_frequency);
} }
@ -259,7 +259,7 @@ void ise_imag_self_energy_at_triplet(
n2[j * num_band + g_pos[i][2]] < 0) { n2[j * num_band + g_pos[i][2]] < 0) {
ise_at_g_pos[i * num_temps + j] = 0; ise_at_g_pos[i * num_temps + j] = 0;
} else { } else {
if (temperatures[j] > 0) { if (temperatures_THz[j] > 0) {
ise_at_g_pos[i * num_temps + j] = ise_at_g_pos[i * num_temps + j] =
((n1[j * num_band + g_pos[i][1]] + ((n1[j * num_band + g_pos[i][1]] +
n2[j * num_band + g_pos[i][2]] + 1) * n2[j * num_band + g_pos[i][2]] + 1) *
@ -359,7 +359,7 @@ static void detailed_imag_self_energy_at_triplet(
const int64_t num_band0, const int64_t num_band, const int64_t num_band0, const int64_t num_band,
const double *fc3_normal_squared, const double *frequencies, const double *fc3_normal_squared, const double *frequencies,
const int64_t triplet[3], const double *g1, const double *g2_3, const int64_t triplet[3], const double *g1, const double *g2_3,
const char *g_zero, const double *temperatures, const int64_t num_temps, const char *g_zero, const double *temperatures_THz, const int64_t num_temps,
const double cutoff_frequency) { const double cutoff_frequency) {
int64_t i, j, adrs_shift; int64_t i, j, adrs_shift;
double *n1, *n2; double *n1, *n2;
@ -371,12 +371,12 @@ static void detailed_imag_self_energy_at_triplet(
n2 = (double *)malloc(sizeof(double) * num_band); n2 = (double *)malloc(sizeof(double) * num_band);
for (i = 0; i < num_temps; i++) { for (i = 0; i < num_temps; i++) {
set_occupations(n1, n2, num_band, temperatures[i], triplet, frequencies, set_occupations(n1, n2, num_band, temperatures_THz[i], triplet,
cutoff_frequency); frequencies, cutoff_frequency);
for (j = 0; j < num_band0; j++) { for (j = 0; j < num_band0; j++) {
adrs_shift = j * num_band * num_band; adrs_shift = j * num_band * num_band;
if (temperatures[i] > 0) { if (temperatures_THz[i] > 0) {
imag_self_energy[i * num_band0 + j] = imag_self_energy[i * num_band0 + j] =
collect_detailed_imag_self_energy( collect_detailed_imag_self_energy(
detailed_imag_self_energy + adrs_shift, num_band, detailed_imag_self_energy + adrs_shift, num_band,
@ -452,8 +452,8 @@ static double collect_detailed_imag_self_energy_0K(
} }
static void set_occupations(double *n1, double *n2, const int64_t num_band, static void set_occupations(double *n1, double *n2, const int64_t num_band,
const double temperature, const int64_t triplet[3], const double temperature_THz,
const double *frequencies, const int64_t triplet[3], const double *frequencies,
const double cutoff_frequency) { const double cutoff_frequency) {
int64_t j; int64_t j;
double f1, f2; double f1, f2;
@ -462,12 +462,12 @@ static void set_occupations(double *n1, double *n2, const int64_t num_band,
f1 = frequencies[triplet[1] * num_band + j]; f1 = frequencies[triplet[1] * num_band + j];
f2 = frequencies[triplet[2] * num_band + j]; f2 = frequencies[triplet[2] * num_band + j];
if (f1 > cutoff_frequency) { if (f1 > cutoff_frequency) {
n1[j] = funcs_bose_einstein(f1, temperature); n1[j] = funcs_bose_einstein(f1, temperature_THz);
} else { } else {
n1[j] = -1; n1[j] = -1;
} }
if (f2 > cutoff_frequency) { if (f2 > cutoff_frequency) {
n2[j] = funcs_bose_einstein(f2, temperature); n2[j] = funcs_bose_einstein(f2, temperature_THz);
} else { } else {
n2[j] = -1; n2[j] = -1;
} }

6
c/imag_self_energy_with_g.h
View File

@ -44,21 +44,21 @@ void ise_get_imag_self_energy_with_g(
double *imag_self_energy, const Darray *fc3_normal_squared, double *imag_self_energy, const Darray *fc3_normal_squared,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplet_weights, const double *g, const char *g_zero, const int64_t *triplet_weights, const double *g, const char *g_zero,
const double temperature, const double cutoff_frequency, const double temperature_THz, const double cutoff_frequency,
const int64_t num_frequency_points, const int64_t frequency_point_index); const int64_t num_frequency_points, const int64_t frequency_point_index);
void ise_get_detailed_imag_self_energy_with_g( void ise_get_detailed_imag_self_energy_with_g(
double *detailed_imag_self_energy, double *imag_self_energy_N, double *detailed_imag_self_energy, double *imag_self_energy_N,
double *imag_self_energy_U, const Darray *fc3_normal_squared, double *imag_self_energy_U, const Darray *fc3_normal_squared,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplet_weights, const int64_t (*bz_grid_addresses)[3], const int64_t *triplet_weights, const int64_t (*bz_grid_addresses)[3],
const double *g, const char *g_zero, const double temperature, const double *g, const char *g_zero, const double temperature_THz,
const double cutoff_frequency); const double cutoff_frequency);
void ise_imag_self_energy_at_triplet( void ise_imag_self_energy_at_triplet(
double *imag_self_energy, const int64_t num_band0, const int64_t num_band, double *imag_self_energy, const int64_t num_band0, const int64_t num_band,
const double *fc3_normal_squared, const double *frequencies, const double *fc3_normal_squared, const double *frequencies,
const int64_t triplet[3], const int64_t triplet_weight, const double *g1, const int64_t triplet[3], const int64_t triplet_weight, const double *g1,
const double *g2_3, const int64_t (*g_pos)[4], const int64_t num_g_pos, const double *g2_3, const int64_t (*g_pos)[4], const int64_t num_g_pos,
const double *temperatures, const int64_t num_temps, const double *temperatures_THz, const int64_t num_temps,
const double cutoff_frequency, const int64_t openmp_possible, const double cutoff_frequency, const int64_t openmp_possible,
const int64_t at_a_frequency_point); const int64_t at_a_frequency_point);
int64_t ise_set_g_pos(int64_t (*g_pos)[4], const int64_t num_band0, int64_t ise_set_g_pos(int64_t (*g_pos)[4], const int64_t num_band0,

46
c/phono3py.c
View File

@ -130,10 +130,10 @@ int64_t ph3py_get_pp_collision(
const double *fc3, const int64_t is_compact_fc3, const double (*svecs)[3], const double *fc3, const int64_t is_compact_fc3, const double (*svecs)[3],
const int64_t multi_dims[2], const int64_t (*multiplicity)[2], const int64_t multi_dims[2], const int64_t (*multiplicity)[2],
const double *masses, const int64_t *p2s_map, const int64_t *s2p_map, const double *masses, const int64_t *p2s_map, const int64_t *s2p_map,
const Larray *band_indices, const Darray *temperatures, const int64_t is_NU, const Larray *band_indices, const Darray *temperatures_THz,
const int64_t symmetrize_fc3_q, const int64_t make_r0_average, const int64_t is_NU, const int64_t symmetrize_fc3_q,
const char *all_shortest, const double cutoff_frequency, const int64_t make_r0_average, const char *all_shortest,
const int64_t openmp_per_triplets) { const double cutoff_frequency, const int64_t openmp_per_triplets) {
RecgridConstBZGrid *bzgrid; RecgridConstBZGrid *bzgrid;
AtomTriplets *atom_triplets; AtomTriplets *atom_triplets;
int64_t i, j; int64_t i, j;
@ -174,7 +174,7 @@ int64_t ph3py_get_pp_collision(
(lapack_complex_double *)eigenvectors, triplets, (lapack_complex_double *)eigenvectors, triplets,
num_triplets, triplet_weights, bzgrid, fc3, num_triplets, triplet_weights, bzgrid, fc3,
is_compact_fc3, atom_triplets, masses, band_indices, is_compact_fc3, atom_triplets, masses, band_indices,
temperatures, is_NU, symmetrize_fc3_q, temperatures_THz, is_NU, symmetrize_fc3_q,
cutoff_frequency, openmp_per_triplets); cutoff_frequency, openmp_per_triplets);
free(atom_triplets); free(atom_triplets);
@ -195,10 +195,10 @@ int64_t ph3py_get_pp_collision_with_sigma(
const int64_t is_compact_fc3, const double (*svecs)[3], const int64_t is_compact_fc3, const double (*svecs)[3],
const int64_t multi_dims[2], const int64_t (*multiplicity)[2], const int64_t multi_dims[2], const int64_t (*multiplicity)[2],
const double *masses, const int64_t *p2s_map, const int64_t *s2p_map, const double *masses, const int64_t *p2s_map, const int64_t *s2p_map,
const Larray *band_indices, const Darray *temperatures, const int64_t is_NU, const Larray *band_indices, const Darray *temperatures_THz,
const int64_t symmetrize_fc3_q, const int64_t make_r0_average, const int64_t is_NU, const int64_t symmetrize_fc3_q,
const char *all_shortest, const double cutoff_frequency, const int64_t make_r0_average, const char *all_shortest,
const int64_t openmp_per_triplets) { const double cutoff_frequency, const int64_t openmp_per_triplets) {
RecgridConstBZGrid *bzgrid; RecgridConstBZGrid *bzgrid;
AtomTriplets *atom_triplets; AtomTriplets *atom_triplets;
int64_t i, j; int64_t i, j;
@ -237,8 +237,8 @@ int64_t ph3py_get_pp_collision_with_sigma(
imag_self_energy, sigma, sigma_cutoff, frequencies, imag_self_energy, sigma, sigma_cutoff, frequencies,
(lapack_complex_double *)eigenvectors, triplets, num_triplets, (lapack_complex_double *)eigenvectors, triplets, num_triplets,
triplet_weights, bzgrid, fc3, is_compact_fc3, atom_triplets, masses, triplet_weights, bzgrid, fc3, is_compact_fc3, atom_triplets, masses,
band_indices, temperatures, is_NU, symmetrize_fc3_q, cutoff_frequency, band_indices, temperatures_THz, is_NU, symmetrize_fc3_q,
openmp_per_triplets); cutoff_frequency, openmp_per_triplets);
free(atom_triplets); free(atom_triplets);
atom_triplets = NULL; atom_triplets = NULL;
@ -253,11 +253,11 @@ void ph3py_get_imag_self_energy_at_bands_with_g(
double *imag_self_energy, const Darray *fc3_normal_squared, double *imag_self_energy, const Darray *fc3_normal_squared,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplet_weights, const double *g, const char *g_zero, const int64_t *triplet_weights, const double *g, const char *g_zero,
const double temperature, const double cutoff_frequency, const double temperature_THz, const double cutoff_frequency,
const int64_t num_frequency_points, const int64_t frequency_point_index) { const int64_t num_frequency_points, const int64_t frequency_point_index) {
ise_get_imag_self_energy_with_g( ise_get_imag_self_energy_with_g(
imag_self_energy, fc3_normal_squared, frequencies, triplets, imag_self_energy, fc3_normal_squared, frequencies, triplets,
triplet_weights, g, g_zero, temperature, cutoff_frequency, triplet_weights, g, g_zero, temperature_THz, cutoff_frequency,
num_frequency_points, frequency_point_index); num_frequency_points, frequency_point_index);
} }
@ -266,23 +266,23 @@ void ph3py_get_detailed_imag_self_energy_at_bands_with_g(
double *imag_self_energy_U, const Darray *fc3_normal_squared, double *imag_self_energy_U, const Darray *fc3_normal_squared,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplet_weights, const int64_t (*bz_grid_addresses)[3], const int64_t *triplet_weights, const int64_t (*bz_grid_addresses)[3],
const double *g, const char *g_zero, const double temperature, const double *g, const char *g_zero, const double temperature_THz,
const double cutoff_frequency) { const double cutoff_frequency) {
ise_get_detailed_imag_self_energy_with_g( ise_get_detailed_imag_self_energy_with_g(
detailed_imag_self_energy, imag_self_energy_N, imag_self_energy_U, detailed_imag_self_energy, imag_self_energy_N, imag_self_energy_U,
fc3_normal_squared, frequencies, triplets, triplet_weights, fc3_normal_squared, frequencies, triplets, triplet_weights,
bz_grid_addresses, g, g_zero, temperature, cutoff_frequency); bz_grid_addresses, g, g_zero, temperature_THz, cutoff_frequency);
} }
void ph3py_get_real_self_energy_at_bands( void ph3py_get_real_self_energy_at_bands(
double *real_self_energy, const Darray *fc3_normal_squared, double *real_self_energy, const Darray *fc3_normal_squared,
const int64_t *band_indices, const double *frequencies, const int64_t *band_indices, const double *frequencies,
const int64_t (*triplets)[3], const int64_t *triplet_weights, const int64_t (*triplets)[3], const int64_t *triplet_weights,
const double epsilon, const double temperature, const double epsilon, const double temperature_THz,
const double unit_conversion_factor, const double cutoff_frequency) { const double unit_conversion_factor, const double cutoff_frequency) {
rse_get_real_self_energy_at_bands(real_self_energy, fc3_normal_squared, rse_get_real_self_energy_at_bands(real_self_energy, fc3_normal_squared,
band_indices, frequencies, triplets, band_indices, frequencies, triplets,
triplet_weights, epsilon, temperature, triplet_weights, epsilon, temperature_THz,
unit_conversion_factor, cutoff_frequency); unit_conversion_factor, cutoff_frequency);
} }
@ -291,11 +291,11 @@ void ph3py_get_real_self_energy_at_frequency_point(
const Darray *fc3_normal_squared, const int64_t *band_indices, const Darray *fc3_normal_squared, const int64_t *band_indices,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplet_weights, const double epsilon, const int64_t *triplet_weights, const double epsilon,
const double temperature, const double unit_conversion_factor, const double temperature_THz, const double unit_conversion_factor,
const double cutoff_frequency) { const double cutoff_frequency) {
rse_get_real_self_energy_at_frequency_point( rse_get_real_self_energy_at_frequency_point(
real_self_energy, frequency_point, fc3_normal_squared, band_indices, real_self_energy, frequency_point, fc3_normal_squared, band_indices,
frequencies, triplets, triplet_weights, epsilon, temperature, frequencies, triplets, triplet_weights, epsilon, temperature_THz,
unit_conversion_factor, cutoff_frequency); unit_conversion_factor, cutoff_frequency);
} }
@ -305,12 +305,12 @@ void ph3py_get_collision_matrix(
const int64_t *triplets_map, const int64_t *map_q, const int64_t *triplets_map, const int64_t *map_q,
const int64_t *rotated_grid_points, const double *rotations_cartesian, const int64_t *rotated_grid_points, const double *rotations_cartesian,
const double *g, const int64_t num_ir_gp, const int64_t num_gp, const double *g, const int64_t num_ir_gp, const int64_t num_gp,
const int64_t num_rot, const double temperature, const int64_t num_rot, const double temperature_THz,
const double unit_conversion_factor, const double cutoff_frequency) { const double unit_conversion_factor, const double cutoff_frequency) {
col_get_collision_matrix(collision_matrix, fc3_normal_squared, frequencies, col_get_collision_matrix(collision_matrix, fc3_normal_squared, frequencies,
triplets, triplets_map, map_q, rotated_grid_points, triplets, triplets_map, map_q, rotated_grid_points,
rotations_cartesian, g, num_ir_gp, num_gp, num_rot, rotations_cartesian, g, num_ir_gp, num_gp, num_rot,
temperature, unit_conversion_factor, temperature_THz, unit_conversion_factor,
cutoff_frequency); cutoff_frequency);
} }
@ -318,11 +318,11 @@ void ph3py_get_reducible_collision_matrix(
double *collision_matrix, const Darray *fc3_normal_squared, double *collision_matrix, const Darray *fc3_normal_squared,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplets_map, const int64_t *map_q, const double *g, const int64_t *triplets_map, const int64_t *map_q, const double *g,
const int64_t num_gp, const double temperature, const int64_t num_gp, const double temperature_THz,
const double unit_conversion_factor, const double cutoff_frequency) { const double unit_conversion_factor, const double cutoff_frequency) {
col_get_reducible_collision_matrix( col_get_reducible_collision_matrix(
collision_matrix, fc3_normal_squared, frequencies, triplets, collision_matrix, fc3_normal_squared, frequencies, triplets,
triplets_map, map_q, g, num_gp, temperature, unit_conversion_factor, triplets_map, map_q, g, num_gp, temperature_THz, unit_conversion_factor,
cutoff_frequency); cutoff_frequency);
} }

28
c/phono3py.h
View File

@ -71,10 +71,10 @@ int64_t ph3py_get_pp_collision(
const double *fc3, const int64_t is_compact_fc3, const double (*svecs)[3], const double *fc3, const int64_t is_compact_fc3, const double (*svecs)[3],
const int64_t multi_dims[2], const int64_t (*multi)[2], const int64_t multi_dims[2], const int64_t (*multi)[2],
const double *masses, const int64_t *p2s_map, const int64_t *s2p_map, const double *masses, const int64_t *p2s_map, const int64_t *s2p_map,
const Larray *band_indices, const Darray *temperatures, const int64_t is_NU, const Larray *band_indices, const Darray *temperatures_THz,
const int64_t symmetrize_fc3_q, const int64_t make_r0_average, const int64_t is_NU, const int64_t symmetrize_fc3_q,
const char *all_shortest, const double cutoff_frequency, const int64_t make_r0_average, const char *all_shortest,
const int64_t openmp_per_triplets); const double cutoff_frequency, const int64_t openmp_per_triplets);
int64_t ph3py_get_pp_collision_with_sigma( int64_t ph3py_get_pp_collision_with_sigma(
double *imag_self_energy, const double sigma, const double sigma_cutoff, double *imag_self_energy, const double sigma, const double sigma_cutoff,
const double *frequencies, const _lapack_complex_double *eigenvectors, const double *frequencies, const _lapack_complex_double *eigenvectors,
@ -84,35 +84,35 @@ int64_t ph3py_get_pp_collision_with_sigma(
const int64_t is_compact_fc3, const double (*svecs)[3], const int64_t is_compact_fc3, const double (*svecs)[3],
const int64_t multi_dims[2], const int64_t (*multi)[2], const int64_t multi_dims[2], const int64_t (*multi)[2],
const double *masses, const int64_t *p2s_map, const int64_t *s2p_map, const double *masses, const int64_t *p2s_map, const int64_t *s2p_map,
const Larray *band_indices, const Darray *temperatures, const int64_t is_NU, const Larray *band_indices, const Darray *temperatures_THz,
const int64_t symmetrize_fc3_q, const int64_t make_r0_average, const int64_t is_NU, const int64_t symmetrize_fc3_q,
const char *all_shortest, const double cutoff_frequency, const int64_t make_r0_average, const char *all_shortest,
const int64_t openmp_per_triplets); const double cutoff_frequency, const int64_t openmp_per_triplets);
void ph3py_get_imag_self_energy_at_bands_with_g( void ph3py_get_imag_self_energy_at_bands_with_g(
double *imag_self_energy, const Darray *fc3_normal_squared, double *imag_self_energy, const Darray *fc3_normal_squared,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplet_weights, const double *g, const char *g_zero, const int64_t *triplet_weights, const double *g, const char *g_zero,
const double temperature, const double cutoff_frequency, const double temperature_THz, const double cutoff_frequency,
const int64_t num_frequency_points, const int64_t frequency_point_index); const int64_t num_frequency_points, const int64_t frequency_point_index);
void ph3py_get_detailed_imag_self_energy_at_bands_with_g( void ph3py_get_detailed_imag_self_energy_at_bands_with_g(
double *detailed_imag_self_energy, double *imag_self_energy_N, double *detailed_imag_self_energy, double *imag_self_energy_N,
double *imag_self_energy_U, const Darray *fc3_normal_squared, double *imag_self_energy_U, const Darray *fc3_normal_squared,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplet_weights, const int64_t (*bz_grid_addresses)[3], const int64_t *triplet_weights, const int64_t (*bz_grid_addresses)[3],
const double *g, const char *g_zero, const double temperature, const double *g, const char *g_zero, const double temperature_THz,
const double cutoff_frequency); const double cutoff_frequency);
void ph3py_get_real_self_energy_at_bands( void ph3py_get_real_self_energy_at_bands(
double *real_self_energy, const Darray *fc3_normal_squared, double *real_self_energy, const Darray *fc3_normal_squared,
const int64_t *band_indices, const double *frequencies, const int64_t *band_indices, const double *frequencies,
const int64_t (*triplets)[3], const int64_t *triplet_weights, const int64_t (*triplets)[3], const int64_t *triplet_weights,
const double epsilon, const double temperature, const double epsilon, const double temperature_THz,
const double unit_conversion_factor, const double cutoff_frequency); const double unit_conversion_factor, const double cutoff_frequency);
void ph3py_get_real_self_energy_at_frequency_point( void ph3py_get_real_self_energy_at_frequency_point(
double *real_self_energy, const double frequency_point, double *real_self_energy, const double frequency_point,
const Darray *fc3_normal_squared, const int64_t *band_indices, const Darray *fc3_normal_squared, const int64_t *band_indices,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplet_weights, const double epsilon, const int64_t *triplet_weights, const double epsilon,
const double temperature, const double unit_conversion_factor, const double temperature_THz, const double unit_conversion_factor,
const double cutoff_frequency); const double cutoff_frequency);
void ph3py_get_collision_matrix( void ph3py_get_collision_matrix(
double *collision_matrix, const Darray *fc3_normal_squared, double *collision_matrix, const Darray *fc3_normal_squared,
@ -120,13 +120,13 @@ void ph3py_get_collision_matrix(
const int64_t *triplets_map, const int64_t *map_q, const int64_t *triplets_map, const int64_t *map_q,
const int64_t *rotated_grid_points, const double *rotations_cartesian, const int64_t *rotated_grid_points, const double *rotations_cartesian,
const double *g, const int64_t num_ir_gp, const int64_t num_gp, const double *g, const int64_t num_ir_gp, const int64_t num_gp,
const int64_t num_rot, const double temperature, const int64_t num_rot, const double temperature_THz,
const double unit_conversion_factor, const double cutoff_frequency); const double unit_conversion_factor, const double cutoff_frequency);
void ph3py_get_reducible_collision_matrix( void ph3py_get_reducible_collision_matrix(
double *collision_matrix, const Darray *fc3_normal_squared, double *collision_matrix, const Darray *fc3_normal_squared,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplets_map, const int64_t *map_q, const double *g, const int64_t *triplets_map, const int64_t *map_q, const double *g,
const int64_t num_gp, const double temperature, const int64_t num_gp, const double temperature_THz,
const double unit_conversion_factor, const double cutoff_frequency); const double unit_conversion_factor, const double cutoff_frequency);
void ph3py_get_isotope_scattering_strength( void ph3py_get_isotope_scattering_strength(
double *gamma, const int64_t grid_point, const int64_t *ir_grid_points, double *gamma, const int64_t grid_point, const int64_t *ir_grid_points,

40
c/pp_collision.c
View File

@ -50,7 +50,7 @@
static void get_collision( static void get_collision(
double *ise, const int64_t num_band0, const int64_t num_band, double *ise, const int64_t num_band0, const int64_t num_band,
const int64_t num_temps, const double *temperatures, const double *g, const int64_t num_temps, const double *temperatures_THz, const double *g,
const char *g_zero, const double *frequencies, const char *g_zero, const double *frequencies,
const lapack_complex_double *eigenvectors, const int64_t triplet[3], const lapack_complex_double *eigenvectors, const int64_t triplet[3],
const int64_t triplet_weight, const RecgridConstBZGrid *bzgrid, const int64_t triplet_weight, const RecgridConstBZGrid *bzgrid,
@ -72,9 +72,9 @@ void ppc_get_pp_collision(
const int64_t *triplet_weights, const RecgridConstBZGrid *bzgrid, const int64_t *triplet_weights, const RecgridConstBZGrid *bzgrid,
const double *fc3, const int64_t is_compact_fc3, const double *fc3, const int64_t is_compact_fc3,
const AtomTriplets *atom_triplets, const double *masses, const AtomTriplets *atom_triplets, const double *masses,
const Larray *band_indices, const Darray *temperatures, const int64_t is_NU, const Larray *band_indices, const Darray *temperatures_THz,
const int64_t symmetrize_fc3_q, const double cutoff_frequency, const int64_t is_NU, const int64_t symmetrize_fc3_q,
const int64_t openmp_per_triplets) { const double cutoff_frequency, const int64_t openmp_per_triplets) {
int64_t i; int64_t i;
int64_t num_band, num_band0, num_band_prod, num_temps; int64_t num_band, num_band0, num_band_prod, num_temps;
double *ise, *freqs_at_gp, *g; double *ise, *freqs_at_gp, *g;
@ -89,7 +89,7 @@ void ppc_get_pp_collision(
num_band0 = band_indices->dims[0]; num_band0 = band_indices->dims[0];
num_band = atom_triplets->multi_dims[1] * 3; num_band = atom_triplets->multi_dims[1] * 3;
num_band_prod = num_band0 * num_band * num_band; num_band_prod = num_band0 * num_band * num_band;
num_temps = temperatures->dims[0]; num_temps = temperatures_THz->dims[0];
ise = ise =
(double *)malloc(sizeof(double) * num_triplets * num_temps * num_band0); (double *)malloc(sizeof(double) * num_triplets * num_temps * num_band0);
freqs_at_gp = (double *)malloc(sizeof(double) * num_band0); freqs_at_gp = (double *)malloc(sizeof(double) * num_band0);
@ -101,8 +101,8 @@ void ppc_get_pp_collision(
tpl_set_relative_grid_address(tp_relative_grid_address, tpl_set_relative_grid_address(tp_relative_grid_address,
relative_grid_address, 2); relative_grid_address, 2);
#ifdef _OPENMP #ifdef _OPENMP
#pragma omp parallel for schedule(guided) private( \ #pragma omp parallel for schedule(guided) \
g, g_zero) if (openmp_per_triplets) private(g, g_zero) if (openmp_per_triplets)
#endif #endif
for (i = 0; i < num_triplets; i++) { for (i = 0; i < num_triplets; i++) {
g = (double *)malloc(sizeof(double) * 2 * num_band_prod); g = (double *)malloc(sizeof(double) * 2 * num_band_prod);
@ -115,7 +115,7 @@ void ppc_get_pp_collision(
num_band, 2, openmp_per_triplets); num_band, 2, openmp_per_triplets);
get_collision(ise + i * num_temps * num_band0, num_band0, num_band, get_collision(ise + i * num_temps * num_band0, num_band0, num_band,
num_temps, temperatures->data, g, g_zero, frequencies, num_temps, temperatures_THz->data, g, g_zero, frequencies,
eigenvectors, triplets[i], triplet_weights[i], bzgrid, eigenvectors, triplets[i], triplet_weights[i], bzgrid,
fc3, is_compact_fc3, atom_triplets, masses, fc3, is_compact_fc3, atom_triplets, masses,
band_indices->data, symmetrize_fc3_q, cutoff_frequency, band_indices->data, symmetrize_fc3_q, cutoff_frequency,
@ -143,9 +143,9 @@ void ppc_get_pp_collision_with_sigma(
const int64_t *triplet_weights, const RecgridConstBZGrid *bzgrid, const int64_t *triplet_weights, const RecgridConstBZGrid *bzgrid,
const double *fc3, const int64_t is_compact_fc3, const double *fc3, const int64_t is_compact_fc3,
const AtomTriplets *atom_triplets, const double *masses, const AtomTriplets *atom_triplets, const double *masses,
const Larray *band_indices, const Darray *temperatures, const int64_t is_NU, const Larray *band_indices, const Darray *temperatures_THz,
const int64_t symmetrize_fc3_q, const double cutoff_frequency, const int64_t is_NU, const int64_t symmetrize_fc3_q,
const int64_t openmp_per_triplets) { const double cutoff_frequency, const int64_t openmp_per_triplets) {
int64_t i; int64_t i;
int64_t num_band, num_band0, num_band_prod, num_temps; int64_t num_band, num_band0, num_band_prod, num_temps;
int64_t const_adrs_shift; int64_t const_adrs_shift;
@ -161,7 +161,7 @@ void ppc_get_pp_collision_with_sigma(
num_band0 = band_indices->dims[0]; num_band0 = band_indices->dims[0];
num_band = atom_triplets->multi_dims[1] * 3; num_band = atom_triplets->multi_dims[1] * 3;
num_band_prod = num_band0 * num_band * num_band; num_band_prod = num_band0 * num_band * num_band;
num_temps = temperatures->dims[0]; num_temps = temperatures_THz->dims[0];
const_adrs_shift = num_band_prod; const_adrs_shift = num_band_prod;
ise = ise =
@ -175,8 +175,8 @@ void ppc_get_pp_collision_with_sigma(
cutoff = sigma * sigma_cutoff; cutoff = sigma * sigma_cutoff;
#ifdef _OPENMP #ifdef _OPENMP
#pragma omp parallel for schedule(guided) private( \ #pragma omp parallel for schedule(guided) \
g, g_zero) if (openmp_per_triplets) private(g, g_zero) if (openmp_per_triplets)
#endif #endif
for (i = 0; i < num_triplets; i++) { for (i = 0; i < num_triplets; i++) {
g = (double *)malloc(sizeof(double) * 2 * num_band_prod); g = (double *)malloc(sizeof(double) * 2 * num_band_prod);
@ -186,7 +186,7 @@ void ppc_get_pp_collision_with_sigma(
const_adrs_shift, frequencies, num_band, 2, 1); const_adrs_shift, frequencies, num_band, 2, 1);
get_collision(ise + i * num_temps * num_band0, num_band0, num_band, get_collision(ise + i * num_temps * num_band0, num_band0, num_band,
num_temps, temperatures->data, g, g_zero, frequencies, num_temps, temperatures_THz->data, g, g_zero, frequencies,
eigenvectors, triplets[i], triplet_weights[i], bzgrid, eigenvectors, triplets[i], triplet_weights[i], bzgrid,
fc3, is_compact_fc3, atom_triplets, masses, fc3, is_compact_fc3, atom_triplets, masses,
band_indices->data, symmetrize_fc3_q, cutoff_frequency, band_indices->data, symmetrize_fc3_q, cutoff_frequency,
@ -209,7 +209,7 @@ void ppc_get_pp_collision_with_sigma(
static void get_collision( static void get_collision(
double *ise, const int64_t num_band0, const int64_t num_band, double *ise, const int64_t num_band0, const int64_t num_band,
const int64_t num_temps, const double *temperatures, const double *g, const int64_t num_temps, const double *temperatures_THz, const double *g,
const char *g_zero, const double *frequencies, const char *g_zero, const double *frequencies,
const lapack_complex_double *eigenvectors, const int64_t triplet[3], const lapack_complex_double *eigenvectors, const int64_t triplet[3],
const int64_t triplet_weight, const RecgridConstBZGrid *bzgrid, const int64_t triplet_weight, const RecgridConstBZGrid *bzgrid,
@ -220,14 +220,14 @@ static void get_collision(
int64_t i; int64_t i;
int64_t num_band_prod, num_g_pos; int64_t num_band_prod, num_g_pos;
double *fc3_normal_squared; double *fc3_normal_squared;
int64_t(*g_pos)[4]; int64_t (*g_pos)[4];
fc3_normal_squared = NULL; fc3_normal_squared = NULL;
g_pos = NULL; g_pos = NULL;
num_band_prod = num_band0 * num_band * num_band; num_band_prod = num_band0 * num_band * num_band;
fc3_normal_squared = (double *)malloc(sizeof(double) * num_band_prod); fc3_normal_squared = (double *)malloc(sizeof(double) * num_band_prod);
g_pos = (int64_t(*)[4])malloc(sizeof(int64_t[4]) * num_band_prod); g_pos = (int64_t (*)[4])malloc(sizeof(int64_t[4]) * num_band_prod);
for (i = 0; i < num_band_prod; i++) { for (i = 0; i < num_band_prod; i++) {
fc3_normal_squared[i] = 0; fc3_normal_squared[i] = 0;
@ -243,8 +243,8 @@ static void get_collision(
ise_imag_self_energy_at_triplet( ise_imag_self_energy_at_triplet(
ise, num_band0, num_band, fc3_normal_squared, frequencies, triplet, ise, num_band0, num_band, fc3_normal_squared, frequencies, triplet,
triplet_weight, g, g + num_band_prod, g_pos, num_g_pos, temperatures, triplet_weight, g, g + num_band_prod, g_pos, num_g_pos,
num_temps, cutoff_frequency, openmp_per_triplets, 0); temperatures_THz, num_temps, cutoff_frequency, openmp_per_triplets, 0);
free(fc3_normal_squared); free(fc3_normal_squared);
fc3_normal_squared = NULL; fc3_normal_squared = NULL;

12
c/pp_collision.h
View File

@ -50,9 +50,9 @@ void ppc_get_pp_collision(
const int64_t *triplet_weights, const RecgridConstBZGrid *bzgrid, const int64_t *triplet_weights, const RecgridConstBZGrid *bzgrid,
const double *fc3, const int64_t is_compact_fc3, const double *fc3, const int64_t is_compact_fc3,
const AtomTriplets *atom_triplets, const double *masses, const AtomTriplets *atom_triplets, const double *masses,
const Larray *band_indices, const Darray *temperatures, const int64_t is_NU, const Larray *band_indices, const Darray *temperatures_THz,
const int64_t symmetrize_fc3_q, const double cutoff_frequency, const int64_t is_NU, const int64_t symmetrize_fc3_q,
const int64_t openmp_per_triplets); const double cutoff_frequency, const int64_t openmp_per_triplets);
void ppc_get_pp_collision_with_sigma( void ppc_get_pp_collision_with_sigma(
double *imag_self_energy, const double sigma, const double sigma_cutoff, double *imag_self_energy, const double sigma, const double sigma_cutoff,
const double *frequencies, const lapack_complex_double *eigenvectors, const double *frequencies, const lapack_complex_double *eigenvectors,
@ -60,8 +60,8 @@ void ppc_get_pp_collision_with_sigma(
const int64_t *triplet_weights, const RecgridConstBZGrid *bzgrid, const int64_t *triplet_weights, const RecgridConstBZGrid *bzgrid,
const double *fc3, const int64_t is_compact_fc3, const double *fc3, const int64_t is_compact_fc3,
const AtomTriplets *atom_triplets, const double *masses, const AtomTriplets *atom_triplets, const double *masses,
const Larray *band_indices, const Darray *temperatures, const int64_t is_NU, const Larray *band_indices, const Darray *temperatures_THz,
const int64_t symmetrize_fc3_q, const double cutoff_frequency, const int64_t is_NU, const int64_t symmetrize_fc3_q,
const int64_t openmp_per_triplets); const double cutoff_frequency, const int64_t openmp_per_triplets);
#endif #endif

28
c/real_self_energy.c
View File

@ -46,12 +46,12 @@ static double get_real_self_energy_at_band(
const int64_t band_index, const Darray *fc3_normal_squared, const int64_t band_index, const Darray *fc3_normal_squared,
const double fpoint, const double *frequencies, const double fpoint, const double *frequencies,
const int64_t (*triplets)[3], const int64_t *triplet_weights, const int64_t (*triplets)[3], const int64_t *triplet_weights,
const double epsilon, const double temperature, const double epsilon, const double temperature_THz,
const double unit_conversion_factor, const double cutoff_frequency); const double unit_conversion_factor, const double cutoff_frequency);
static double sum_real_self_energy_at_band( static double sum_real_self_energy_at_band(
const int64_t num_band, const double *fc3_normal_squared, const int64_t num_band, const double *fc3_normal_squared,
const double fpoint, const double *freqs1, const double *freqs2, const double fpoint, const double *freqs1, const double *freqs2,
const double epsilon, const double temperature, const double epsilon, const double temperature_THz,
const double cutoff_frequency); const double cutoff_frequency);
static double sum_real_self_energy_at_band_0K( static double sum_real_self_energy_at_band_0K(
const int64_t num_band, const double *fc3_normal_squared, const int64_t num_band, const double *fc3_normal_squared,
@ -62,7 +62,7 @@ void rse_get_real_self_energy_at_bands(
double *real_self_energy, const Darray *fc3_normal_squared, double *real_self_energy, const Darray *fc3_normal_squared,
const int64_t *band_indices, const double *frequencies, const int64_t *band_indices, const double *frequencies,
const int64_t (*triplets)[3], const int64_t *triplet_weights, const int64_t (*triplets)[3], const int64_t *triplet_weights,
const double epsilon, const double temperature, const double epsilon, const double temperature_THz,
const double unit_conversion_factor, const double cutoff_frequency) { const double unit_conversion_factor, const double cutoff_frequency) {
int64_t i, num_band0, num_band, gp0; int64_t i, num_band0, num_band, gp0;
double fpoint; double fpoint;
@ -79,8 +79,8 @@ void rse_get_real_self_energy_at_bands(
} else { } else {
real_self_energy[i] = get_real_self_energy_at_band( real_self_energy[i] = get_real_self_energy_at_band(
i, fc3_normal_squared, fpoint, frequencies, triplets, i, fc3_normal_squared, fpoint, frequencies, triplets,
triplet_weights, epsilon, temperature, unit_conversion_factor, triplet_weights, epsilon, temperature_THz,
cutoff_frequency); unit_conversion_factor, cutoff_frequency);
} }
} }
} }
@ -90,7 +90,7 @@ void rse_get_real_self_energy_at_frequency_point(
const Darray *fc3_normal_squared, const int64_t *band_indices, const Darray *fc3_normal_squared, const int64_t *band_indices,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplet_weights, const double epsilon, const int64_t *triplet_weights, const double epsilon,
const double temperature, const double unit_conversion_factor, const double temperature_THz, const double unit_conversion_factor,
const double cutoff_frequency) { const double cutoff_frequency) {
int64_t i, num_band0; int64_t i, num_band0;
@ -103,8 +103,8 @@ void rse_get_real_self_energy_at_frequency_point(
} else { } else {
real_self_energy[i] = get_real_self_energy_at_band( real_self_energy[i] = get_real_self_energy_at_band(
i, fc3_normal_squared, frequency_point, frequencies, triplets, i, fc3_normal_squared, frequency_point, frequencies, triplets,
triplet_weights, epsilon, temperature, unit_conversion_factor, triplet_weights, epsilon, temperature_THz,
cutoff_frequency); unit_conversion_factor, cutoff_frequency);
} }
} }
} }
@ -113,7 +113,7 @@ static double get_real_self_energy_at_band(
const int64_t band_index, const Darray *fc3_normal_squared, const int64_t band_index, const Darray *fc3_normal_squared,
const double fpoint, const double *frequencies, const double fpoint, const double *frequencies,
const int64_t (*triplets)[3], const int64_t *triplet_weights, const int64_t (*triplets)[3], const int64_t *triplet_weights,
const double epsilon, const double temperature, const double epsilon, const double temperature_THz,
const double unit_conversion_factor, const double cutoff_frequency) { const double unit_conversion_factor, const double cutoff_frequency) {
int64_t i, num_triplets, num_band0, num_band, gp1, gp2; int64_t i, num_triplets, num_band0, num_band, gp1, gp2;
double shift; double shift;
@ -129,14 +129,14 @@ static double get_real_self_energy_at_band(
for (i = 0; i < num_triplets; i++) { for (i = 0; i < num_triplets; i++) {
gp1 = triplets[i][1]; gp1 = triplets[i][1];
gp2 = triplets[i][2]; gp2 = triplets[i][2];
if (temperature > 0) { if (temperature_THz > 0) {
shift += sum_real_self_energy_at_band( shift += sum_real_self_energy_at_band(
num_band, num_band,
fc3_normal_squared->data + fc3_normal_squared->data +
i * num_band0 * num_band * num_band + i * num_band0 * num_band * num_band +
band_index * num_band * num_band, band_index * num_band * num_band,
fpoint, frequencies + gp1 * num_band, fpoint, frequencies + gp1 * num_band,
frequencies + gp2 * num_band, epsilon, temperature, frequencies + gp2 * num_band, epsilon, temperature_THz,
cutoff_frequency) * cutoff_frequency) *
triplet_weights[i] * unit_conversion_factor; triplet_weights[i] * unit_conversion_factor;
} else { } else {
@ -157,7 +157,7 @@ static double get_real_self_energy_at_band(
static double sum_real_self_energy_at_band( static double sum_real_self_energy_at_band(
const int64_t num_band, const double *fc3_normal_squared, const int64_t num_band, const double *fc3_normal_squared,
const double fpoint, const double *freqs1, const double *freqs2, const double fpoint, const double *freqs1, const double *freqs2,
const double epsilon, const double temperature, const double epsilon, const double temperature_THz,
const double cutoff_frequency) { const double cutoff_frequency) {
int64_t i, j; int64_t i, j;
double n1, n2, f1, f2, f3, f4, shift; double n1, n2, f1, f2, f3, f4, shift;
@ -166,10 +166,10 @@ static double sum_real_self_energy_at_band(
shift = 0; shift = 0;
for (i = 0; i < num_band; i++) { for (i = 0; i < num_band; i++) {
if (freqs1[i] > cutoff_frequency) { if (freqs1[i] > cutoff_frequency) {
n1 = funcs_bose_einstein(freqs1[i], temperature); n1 = funcs_bose_einstein(freqs1[i], temperature_THz);
for (j = 0; j < num_band; j++) { for (j = 0; j < num_band; j++) {
if (freqs2[j] > cutoff_frequency) { if (freqs2[j] > cutoff_frequency) {
n2 = funcs_bose_einstein(freqs2[j], temperature); n2 = funcs_bose_einstein(freqs2[j], temperature_THz);
f1 = fpoint + freqs1[i] + freqs2[j]; f1 = fpoint + freqs1[i] + freqs2[j];
f2 = fpoint - freqs1[i] - freqs2[j]; f2 = fpoint - freqs1[i] - freqs2[j];
f3 = fpoint - freqs1[i] + freqs2[j]; f3 = fpoint - freqs1[i] + freqs2[j];

4
c/real_self_energy.h
View File

@ -45,12 +45,12 @@ void rse_get_real_self_energy_at_bands(
double *real_self_energy, const Darray *fc3_normal_squared, double *real_self_energy, const Darray *fc3_normal_squared,
const int64_t *band_indices, const double *frequencies, const int64_t *band_indices, const double *frequencies,
const int64_t (*triplets)[3], const int64_t *triplet_weights, const int64_t (*triplets)[3], const int64_t *triplet_weights,
const double epsilon, const double temperature, const double epsilon, const double temperature_THz,
const double unit_conversion_factor, const double cutoff_frequency); const double unit_conversion_factor, const double cutoff_frequency);
void rse_get_real_self_energy_at_frequency_point( void rse_get_real_self_energy_at_frequency_point(
double *real_self_energy, const double frequency_point, double *real_self_energy, const double frequency_point,
const Darray *fc3_normal_squared, const int64_t *band_indices, const Darray *fc3_normal_squared, const int64_t *band_indices,
const double *frequencies, const int64_t (*triplets)[3], const double *frequencies, const int64_t (*triplets)[3],
const int64_t *triplet_weights, const double epsilon, const int64_t *triplet_weights, const double epsilon,
const double temperature, const double unit_conversion_factor, const double temperature_THz, const double unit_conversion_factor,
const double cutoff_frequency); const double cutoff_frequency);

2
phono3py/api_jointdos.py
View File

@ -88,7 +88,7 @@ class Phono3pyJointDos:
self._sigmas = sigmas self._sigmas = sigmas
self._cutoff_frequency = cutoff_frequency self._cutoff_frequency = cutoff_frequency
if frequency_factor_to_THz is None: if frequency_factor_to_THz is None:
self._frequency_factor_to_THz = get_physical_units().defaultToTHz self._frequency_factor_to_THz = get_physical_units().DefaultToTHz
else: else:
self._frequency_factor_to_THz = frequency_factor_to_THz self._frequency_factor_to_THz = frequency_factor_to_THz
self._frequency_scale_factor = frequency_scale_factor self._frequency_scale_factor = frequency_scale_factor

2
phono3py/api_phono3py.py
View File

@ -219,7 +219,7 @@ class Phono3py:
""" """
self._symprec = symprec self._symprec = symprec
if frequency_factor_to_THz is None: if frequency_factor_to_THz is None:
self._frequency_factor_to_THz = get_physical_units().defaultToTHz self._frequency_factor_to_THz = get_physical_units().DefaultToTHz
else: else:
self._frequency_factor_to_THz = frequency_factor_to_THz self._frequency_factor_to_THz = frequency_factor_to_THz
self._is_symmetry = is_symmetry self._is_symmetry = is_symmetry

2
phono3py/conductivity/base.py
View File

@ -115,7 +115,7 @@ class HeatCapacityMixIn:
# Otherwise just set 0. # Otherwise just set 0.
for i, f in enumerate(freqs): for i, f in enumerate(freqs):
if f > cutoff: if f > cutoff:
condition = f < 100 * self._temperatures * get_physical_units().Kb condition = f < 100 * self._temperatures * get_physical_units().KB
cv[:, i] = np.where( cv[:, i] = np.where(
condition, condition,
mode_cv(np.where(condition, self._temperatures, 10000), f), mode_cv(np.where(condition, self._temperatures, 10000), f),

10
phono3py/conductivity/direct_solution_base.py
View File

@ -792,7 +792,7 @@ class ConductivityLBTEBase(ConductivityBase):
sinh = np.where( sinh = np.where(
freqs > self._pp.cutoff_frequency, freqs > self._pp.cutoff_frequency,
np.sinh( np.sinh(
freqs * get_physical_units().THzToEv / (2 * get_physical_units().Kb * t) freqs * get_physical_units().THzToEv / (2 * get_physical_units().KB * t)
), ),
-1.0, -1.0,
) )
@ -801,7 +801,7 @@ class ConductivityLBTEBase(ConductivityBase):
freqs freqs
* get_physical_units().THzToEv * get_physical_units().THzToEv
* inv_sinh * inv_sinh
/ (4 * get_physical_units().Kb * t**2) / (4 * get_physical_units().KB * t**2)
) )
for i, f in enumerate(freqs_sinh): for i, f in enumerate(freqs_sinh):
@ -1088,7 +1088,7 @@ class ConductivityLBTEBase(ConductivityBase):
t = self._temperatures[i_temp] t = self._temperatures[i_temp]
mode_kappa[i_sigma, i_temp] *= ( mode_kappa[i_sigma, i_temp] *= (
self._conversion_factor * get_physical_units().Kb * t**2 self._conversion_factor * get_physical_units().KB * t**2
) )
def _set_mode_kappa_Chaput(self, mode_kappa, i_sigma, i_temp, weights): def _set_mode_kappa_Chaput(self, mode_kappa, i_sigma, i_temp, weights):
@ -1133,7 +1133,7 @@ class ConductivityLBTEBase(ConductivityBase):
vals = vals.reshape(num_ir_grid_points, num_band) vals = vals.reshape(num_ir_grid_points, num_band)
mode_kappa[i_sigma, i_temp, :, :, i] += vals mode_kappa[i_sigma, i_temp, :, :, i] += vals
factor = self._conversion_factor * get_physical_units().Kb * t**2 factor = self._conversion_factor * get_physical_units().KB * t**2
mode_kappa[i_sigma, i_temp] *= factor mode_kappa[i_sigma, i_temp] *= factor
def _set_mode_kappa_from_mfp(self, weights, rotations_cartesian, i_sigma, i_temp): def _set_mode_kappa_from_mfp(self, weights, rotations_cartesian, i_sigma, i_temp):
@ -1160,7 +1160,7 @@ class ConductivityLBTEBase(ConductivityBase):
if cv < 1e-10: if cv < 1e-10:
continue continue
self._mfp[i_sigma, i_temp, i, j] = ( self._mfp[i_sigma, i_temp, i, j] = (
-2 * t * np.sqrt(get_physical_units().Kb / cv) * f / (2 * np.pi) -2 * t * np.sqrt(get_physical_units().KB / cv) * f / (2 * np.pi)
) )
def _show_log(self, i): def _show_log(self, i):

2
phono3py/conductivity/kubo_base.py
View File

@ -75,7 +75,7 @@ class ConductivityKuboMixIn:
cutoff = self._pp.cutoff_frequency * get_physical_units().THzToEv cutoff = self._pp.cutoff_frequency * get_physical_units().THzToEv
for i_temp, temp in enumerate(self._temperatures): for i_temp, temp in enumerate(self._temperatures):
if (freqs / (temp * get_physical_units().Kb) > 100).any(): if (freqs / (temp * get_physical_units().KB) > 100).any():
continue continue
cvm = mode_cv_matrix(temp, freqs, cutoff=cutoff) cvm = mode_cv_matrix(temp, freqs, cutoff=cutoff)
self._cv_mat[i_temp, i_data] = cvm[self._pp.band_indices, :] self._cv_mat[i_temp, i_data] = cvm[self._pp.band_indices, :]

9
phono3py/conductivity/rta_base.py
View File

@ -38,6 +38,7 @@ import warnings
from abc import abstractmethod from abc import abstractmethod
import numpy as np import numpy as np
from phonopy.physical_units import get_physical_units
from phono3py.conductivity.base import ConductivityBase from phono3py.conductivity.base import ConductivityBase
from phono3py.file_IO import read_pp_from_hdf5 from phono3py.file_IO import read_pp_from_hdf5
@ -328,6 +329,10 @@ class ConductivityRTABase(ConductivityBase):
) )
# It is assumed that self._sigmas = [None]. # It is assumed that self._sigmas = [None].
temperatures_THz = np.array(
self._temperatures * get_physical_units().KB / get_physical_units().THzToEv,
dtype="double",
)
for j, sigma in enumerate(self._sigmas): for j, sigma in enumerate(self._sigmas):
self._collision.set_sigma(sigma) self._collision.set_sigma(sigma)
if self._is_N_U: if self._is_N_U:
@ -378,7 +383,7 @@ class ConductivityRTABase(ConductivityBase):
p2s, p2s,
s2p, s2p,
band_indices, band_indices,
self._temperatures, temperatures_THz,
self._is_N_U * 1, self._is_N_U * 1,
self._pp.symmetrize_fc3q * 1, self._pp.symmetrize_fc3q * 1,
self._pp.make_r0_average * 1, self._pp.make_r0_average * 1,
@ -409,7 +414,7 @@ class ConductivityRTABase(ConductivityBase):
p2s, p2s,
s2p, s2p,
band_indices, band_indices,
self._temperatures, temperatures_THz,
self._is_N_U * 1, self._is_N_U * 1,
self._pp.symmetrize_fc3q * 1, self._pp.symmetrize_fc3q * 1,
self._pp.make_r0_average * 1, self._pp.make_r0_average * 1,

2
phono3py/cui/load.py
View File

@ -315,7 +315,7 @@ def load(
cell.cell = cell.cell * factor_to_A cell.cell = cell.cell * factor_to_A
if factor is None: if factor is None:
_factor = get_physical_units().defaultToTHz _factor = get_physical_units().DefaultToTHz
else: else:
_factor = factor _factor = factor
ph3py = Phono3py( ph3py = Phono3py(

4
phono3py/cui/phono3py_script.py
View File

@ -390,7 +390,7 @@ def get_default_values(settings):
temperatures = settings.temperatures # For others temperatures = settings.temperatures # For others
if settings.frequency_conversion_factor is None: if settings.frequency_conversion_factor is None:
frequency_factor_to_THz = get_physical_units().defaultToTHz frequency_factor_to_THz = get_physical_units().DefaultToTHz
else: else:
frequency_factor_to_THz = settings.frequency_conversion_factor frequency_factor_to_THz = settings.frequency_conversion_factor
@ -730,7 +730,7 @@ def run_gruneisen_then_exit(phono3py, settings, output_filename, log_level):
nac_params=phono3py.nac_params, nac_params=phono3py.nac_params,
nac_q_direction=settings.nac_q_direction, nac_q_direction=settings.nac_q_direction,
ion_clamped=settings.ion_clamped, ion_clamped=settings.ion_clamped,
factor=get_physical_units().defaultToTHz, factor=get_physical_units().DefaultToTHz,
symprec=phono3py.symmetry.tolerance, symprec=phono3py.symmetry.tolerance,
output_filename=output_filename, output_filename=output_filename,
log_level=log_level, log_level=log_level,

2
phono3py/other/isotope.py
View File

@ -123,7 +123,7 @@ class Isotope:
else: else:
self._cutoff_frequency = cutoff_frequency self._cutoff_frequency = cutoff_frequency
if frequency_factor_to_THz is None: if frequency_factor_to_THz is None:
self._frequency_factor_to_THz = get_physical_units().defaultToTHz self._frequency_factor_to_THz = get_physical_units().DefaultToTHz
else: else:
self._frequency_factor_to_THz = frequency_factor_to_THz self._frequency_factor_to_THz = frequency_factor_to_THz
self._lapack_zheev_uplo = lapack_zheev_uplo self._lapack_zheev_uplo = lapack_zheev_uplo

2
phono3py/phonon/func.py
View File

@ -63,7 +63,7 @@ def bose_einstein(x, T):
""" """
return 1.0 / ( return 1.0 / (
np.exp(get_physical_units().THzToEv * x / (get_physical_units().Kb * T)) - 1 np.exp(get_physical_units().THzToEv * x / (get_physical_units().KB * T)) - 1
) )

6
phono3py/phonon/heat_capacity_matrix.py
View File

@ -67,8 +67,8 @@ def mode_cv_matrix(temp, freqs, cutoff=1e-4):
shape=(num_band, num_band), dtype='double', order='C'. shape=(num_band, num_band), dtype='double', order='C'.
""" """
Kb = get_physical_units().Kb KB = get_physical_units().KB
x = freqs / Kb / temp x = freqs / KB / temp
shape = (len(freqs), len(freqs)) shape = (len(freqs), len(freqs))
cvm = np.zeros(shape, dtype="double", order="C") cvm = np.zeros(shape, dtype="double", order="C")
for i, j in np.ndindex(shape): for i, j in np.ndindex(shape):
@ -78,5 +78,5 @@ def mode_cv_matrix(temp, freqs, cutoff=1e-4):
sub = x[i] - x[j] sub = x[i] - x[j]
add = x[i] + x[j] add = x[i] + x[j]
n_inv = np.exp([x[i], x[j], sub]) - 1 n_inv = np.exp([x[i], x[j], sub]) - 1
cvm[i, j] = Kb * n_inv[2] / sub * (add / 2) ** 2 / n_inv[0] * (1 / n_inv[1] + 1) cvm[i, j] = KB * n_inv[2] / sub * (add / 2) ** 2 / n_inv[0] * (1 / n_inv[1] + 1)
return cvm return cvm

2
phono3py/phonon/solver.py
View File

@ -85,7 +85,7 @@ def run_phonon_solver_c(
import phono3py._phononcalc as phononcalc import phono3py._phononcalc as phononcalc
if frequency_conversion_factor is None: if frequency_conversion_factor is None:
_frequency_conversion_factor = get_physical_units().defaultToTHz _frequency_conversion_factor = get_physical_units().DefaultToTHz
else: else:
_frequency_conversion_factor = frequency_conversion_factor _frequency_conversion_factor = frequency_conversion_factor

2
phono3py/phonon/velocity_operator.py
View File

@ -76,7 +76,7 @@ class VelocityOperator(GroupVelocity):
self._q_length = 5e-6 self._q_length = 5e-6
self._symmetry = symmetry self._symmetry = symmetry
if frequency_factor_to_THz is None: if frequency_factor_to_THz is None:
self._factor = get_physical_units().defaultToTHz self._factor = get_physical_units().DefaultToTHz
else: else:
self._factor = frequency_factor_to_THz self._factor = frequency_factor_to_THz
self._cutoff_frequency = cutoff_frequency self._cutoff_frequency = cutoff_frequency

6
phono3py/phonon3/collision_matrix.py
View File

@ -164,7 +164,7 @@ class CollisionMatrix(ImagSelfEnergy):
self._ir_map_at_q, self._ir_map_at_q,
self._rot_grid_points, # in GRGrid self._rot_grid_points, # in GRGrid
self._rotations_cartesian, self._rotations_cartesian,
self._temperature, self._temperature * get_physical_units().KB / get_physical_units().THzToEv,
self._unit_conversion, self._unit_conversion,
self._cutoff_frequency, self._cutoff_frequency,
) )
@ -180,7 +180,7 @@ class CollisionMatrix(ImagSelfEnergy):
self._triplets_at_q, self._triplets_at_q,
self._triplets_map_at_q, self._triplets_map_at_q,
self._ir_map_at_q, self._ir_map_at_q,
self._temperature, self._temperature * get_physical_units().KB / get_physical_units().THzToEv,
self._unit_conversion, self._unit_conversion,
self._cutoff_frequency, self._cutoff_frequency,
) )
@ -314,7 +314,7 @@ class CollisionMatrix(ImagSelfEnergy):
np.sinh( np.sinh(
freqs freqs
* get_physical_units().THzToEv * get_physical_units().THzToEv
/ (2 * get_physical_units().Kb * self._temperature) / (2 * get_physical_units().KB * self._temperature)
), ),
-1.0, -1.0,
) )

2
phono3py/phonon3/gruneisen.py
View File

@ -143,7 +143,7 @@ class Gruneisen:
self._pcell = primitive self._pcell = primitive
self._ion_clamped = ion_clamped self._ion_clamped = ion_clamped
if factor is None: if factor is None:
self._factor = get_physical_units().defaultToTHz self._factor = get_physical_units().DefaultToTHz
else: else:
self._factor = factor self._factor = factor
self._symprec = symprec self._symprec = symprec

14
phono3py/phonon3/imag_self_energy.py
View File

@ -292,7 +292,7 @@ class ImagSelfEnergy:
self._temperature = float(temperature) self._temperature = float(temperature)
def set_temperature(self, temperature): def set_temperature(self, temperature):
"""Set temperatures where calculation will be performed.""" """Set temperature where calculation will be performed."""
warnings.warn( warnings.warn(
"Use attribute, ImagSelfEnergy.temperature " "Use attribute, ImagSelfEnergy.temperature "
"instead of ImagSelfEnergy.set_temperature().", "instead of ImagSelfEnergy.set_temperature().",
@ -391,7 +391,7 @@ class ImagSelfEnergy:
self._triplets_at_q, self._triplets_at_q,
self._weights_at_q, self._weights_at_q,
self._frequencies, self._frequencies,
self._temperature, self._temperature * get_physical_units().KB / get_physical_units().THzToEv,
self._g, self._g,
_g_zero, _g_zero,
self._cutoff_frequency, self._cutoff_frequency,
@ -416,7 +416,7 @@ class ImagSelfEnergy:
self._weights_at_q, self._weights_at_q,
self._pp.bz_grid.addresses, self._pp.bz_grid.addresses,
self._frequencies, self._frequencies,
self._temperature, self._temperature * get_physical_units().KB / get_physical_units().THzToEv,
self._g, self._g,
_g_zero, _g_zero,
self._cutoff_frequency, self._cutoff_frequency,
@ -440,7 +440,9 @@ class ImagSelfEnergy:
self._triplets_at_q, self._triplets_at_q,
self._weights_at_q, self._weights_at_q,
self._frequencies, self._frequencies,
self._temperature, self._temperature
* get_physical_units().KB
/ get_physical_units().THzToEv,
self._g, self._g,
self._g_zero, self._g_zero,
self._cutoff_frequency, self._cutoff_frequency,
@ -475,7 +477,9 @@ class ImagSelfEnergy:
self._weights_at_q, self._weights_at_q,
self._pp.bz_grid.addresses, self._pp.bz_grid.addresses,
self._frequencies, self._frequencies,
self._temperature, self._temperature
* get_physical_units().KB
/ get_physical_units().THzToEv,
g, g,
_g_zero, _g_zero,
self._cutoff_frequency, self._cutoff_frequency,

2
phono3py/phonon3/interaction.py
View File

@ -116,7 +116,7 @@ class Interaction:
self._set_band_indices(band_indices) self._set_band_indices(band_indices)
self._constant_averaged_interaction = constant_averaged_interaction self._constant_averaged_interaction = constant_averaged_interaction
if frequency_factor_to_THz is None: if frequency_factor_to_THz is None:
self._frequency_factor_to_THz = get_physical_units().defaultToTHz self._frequency_factor_to_THz = get_physical_units().DefaultToTHz
else: else:
self._frequency_factor_to_THz = frequency_factor_to_THz self._frequency_factor_to_THz = frequency_factor_to_THz
self._frequency_scale_factor = frequency_scale_factor self._frequency_scale_factor = frequency_scale_factor

6
phono3py/phonon3/joint_dos.py
View File

@ -91,7 +91,7 @@ class JointDos:
else: else:
self._cutoff_frequency = cutoff_frequency self._cutoff_frequency = cutoff_frequency
if frequency_factor_to_THz is None: if frequency_factor_to_THz is None:
self._frequency_factor_to_THz = get_physical_units().defaultToTHz self._frequency_factor_to_THz = get_physical_units().DefaultToTHz
else: else:
self._frequency_factor_to_THz = frequency_factor_to_THz self._frequency_factor_to_THz = frequency_factor_to_THz
self._frequency_scale_factor = frequency_scale_factor self._frequency_scale_factor = frequency_scale_factor
@ -391,7 +391,9 @@ class JointDos:
self._triplets_at_q, self._triplets_at_q,
self._weights_at_q, self._weights_at_q,
self._frequencies, self._frequencies,
self._temperature, self._temperature
* get_physical_units().KB
/ get_physical_units().THzToEv,
g, g,
self._g_zero, self._g_zero,
self._cutoff_frequency, self._cutoff_frequency,

6
phono3py/phonon3/real_self_energy.py
View File

@ -245,7 +245,7 @@ class RealSelfEnergy:
self._weights_at_q, self._weights_at_q,
self._frequencies, self._frequencies,
self._band_indices, self._band_indices,
self._temperature, self._temperature * get_physical_units().KB / get_physical_units().THzToEv,
self._epsilon, self._epsilon,
self._unit_conversion, self._unit_conversion,
self._cutoff_frequency, self._cutoff_frequency,
@ -282,7 +282,9 @@ class RealSelfEnergy:
self._weights_at_q, self._weights_at_q,
self._frequencies, self._frequencies,
self._band_indices, self._band_indices,
self._temperature, self._temperature
* get_physical_units().KB
/ get_physical_units().THzToEv,
self._epsilon, self._epsilon,
self._unit_conversion, self._unit_conversion,
self._cutoff_frequency, self._cutoff_frequency,

2
phono3py/sscha/sscha.py
View File

@ -125,7 +125,7 @@ class SupercellPhonon:
eigvals, eigvecs = np.linalg.eigh(dynmat) eigvals, eigvecs = np.linalg.eigh(dynmat)
freqs = np.sqrt(np.abs(eigvals)) * np.sign(eigvals) freqs = np.sqrt(np.abs(eigvals)) * np.sign(eigvals)
if frequency_factor_to_THz is None: if frequency_factor_to_THz is None:
freqs *= get_physical_units().defaultToTHz freqs *= get_physical_units().DefaultToTHz
else: else:
freqs *= frequency_factor_to_THz freqs *= frequency_factor_to_THz
self._eigenvalues = np.array(eigvals, dtype="double", order="C") self._eigenvalues = np.array(eigvals, dtype="double", order="C")

4
test/phonon/test_velocity_operator.py
View File

@ -194,7 +194,7 @@ def test_gv_operator_nacl(ph_nacl: Phonopy):
eigvals, eigvecs = np.linalg.eigh(dm) eigvals, eigvecs = np.linalg.eigh(dm)
np.testing.assert_allclose( np.testing.assert_allclose(
eigvals * get_physical_units().defaultToTHz * get_physical_units().THzToCm, eigvals * get_physical_units().DefaultToTHz * get_physical_units().THzToCm,
eigvals_NaCl_Ref, eigvals_NaCl_Ref,
atol=0.00001, atol=0.00001,
rtol=0.00001, rtol=0.00001,
@ -406,7 +406,7 @@ def test_gv_operator_si(ph_si: Phonopy):
eigvals, eigvecs = np.linalg.eigh(dm) eigvals, eigvecs = np.linalg.eigh(dm)
np.testing.assert_allclose( np.testing.assert_allclose(
eigvals * get_physical_units().defaultToTHz * get_physical_units().THzToCm, eigvals * get_physical_units().DefaultToTHz * get_physical_units().THzToCm,
eigvals_si_Ref, eigvals_si_Ref,
atol=0.00001, atol=0.00001,
rtol=0.00001, rtol=0.00001,