phono3py 3.3.0__tar.gz → 3.3.2__tar.gz

{phono3py-3.3.0 → phono3py-3.3.2}/CMakeLists.txt

@@ -2,6 +2,7 @@ cmake_minimum_required(VERSION 3.20)
 
 option(BUILD_PHPHCALC_LIB "Option to build phph calculation module" OFF)
 option(BUILD_PHONONCALC_LIB "Option to build phonon calculation module" OFF)
+option(BUILD_RECGRID_LIB "Option to build reciprocal space grid module" OFF)
 option(BUILD_GRIDSYS_LIB "Option to build gridsys module" OFF)
 option(PHONO3PY_WITH_Fortran "enable fortran interface" OFF)
 option(PHONO3PY_USE_OMP "Option to search OpenMP library" ON)
@@ -125,27 +126,61 @@ if(BUILD_PHPHCALC_LIB
 endif()
 
 # ###################################################################################
-# Build phphcalc module #
+# Reciprocal space grid library #
+# ###################################################################################
+if(BUILD_RECGRID_LIB
+   OR BUILD_PHPHCALC_LIB
+   OR BUILD_NANOBIND_MODULE)
+    # Source code
+    set(SOURCES_PHPHCALC
+        ${PROJECT_SOURCE_DIR}/c/bzgrid.c ${PROJECT_SOURCE_DIR}/c/grgrid.c
+        ${PROJECT_SOURCE_DIR}/c/lagrid.c ${PROJECT_SOURCE_DIR}/c/snf3x3.c
+        ${PROJECT_SOURCE_DIR}/c/recgrid.c)
+
+    if(BUILD_SHARED_LIBS)
+        # Shared library
+        add_library(recgrid_lib SHARED ${SOURCES_PHPHCALC})
+    else()
+        # Static link library
+        add_library(recgrid_lib STATIC ${SOURCES_PHPHCALC})
+    endif()
+
+    if(NOT BUILD_NANOBIND_MODULE)
+        if(BUILD_SHARED_LIBS)
+            set_property(TARGET recgrid_lib PROPERTY VERSION ${SERIAL})
+            set_property(TARGET recgrid_lib PROPERTY SOVERSION ${SOSERIAL})
+            install(TARGETS recgrid_lib LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+        else()
+            set_property(TARGET recgrid_lib PROPERTY VERSION ${SERIAL})
+            set_property(TARGET recgrid_lib PROPERTY SOVERSION ${SOSERIAL})
+            set_property(TARGET recgrid_lib PROPERTY OUTPUT_NAME recgrid_lib)
+            install(TARGETS recgrid_lib ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+        endif()
+
+        # Header file
+        install(FILES ${PROJECT_SOURCE_DIR}/c/recgrid.h
+                DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+    endif()
+endif()
+
+# ###################################################################################
+# Ph-ph calculation library #
 # ###################################################################################
 if(BUILD_PHPHCALC_LIB OR BUILD_NANOBIND_MODULE)
     # Source code
     set(SOURCES_PHPHCALC
-        ${PROJECT_SOURCE_DIR}/c/bzgrid.c
         ${PROJECT_SOURCE_DIR}/c/collision_matrix.c
         ${PROJECT_SOURCE_DIR}/c/fc3.c
-        ${PROJECT_SOURCE_DIR}/c/grgrid.c
         ${PROJECT_SOURCE_DIR}/c/imag_self_energy_with_g.c
         ${PROJECT_SOURCE_DIR}/c/interaction.c
         ${PROJECT_SOURCE_DIR}/c/isotope.c
-        ${PROJECT_SOURCE_DIR}/c/lagrid.c
         ${PROJECT_SOURCE_DIR}/c/lapack_wrapper.c
         ${PROJECT_SOURCE_DIR}/c/phono3py.c
-        ${PROJECT_SOURCE_DIR}/c/phonoc_utils.c
+        ${PROJECT_SOURCE_DIR}/c/funcs.c
         ${PROJECT_SOURCE_DIR}/c/pp_collision.c
         ${PROJECT_SOURCE_DIR}/c/real_self_energy.c
         ${PROJECT_SOURCE_DIR}/c/real_to_reciprocal.c
         ${PROJECT_SOURCE_DIR}/c/reciprocal_to_normal.c
-        ${PROJECT_SOURCE_DIR}/c/snf3x3.c
         ${PROJECT_SOURCE_DIR}/c/tetrahedron_method.c
         ${PROJECT_SOURCE_DIR}/c/triplet.c
         ${PROJECT_SOURCE_DIR}/c/triplet_grid.c
@@ -156,10 +191,12 @@ if(BUILD_PHPHCALC_LIB OR BUILD_NANOBIND_MODULE)
         add_library(phphcalc_lib SHARED ${SOURCES_PHPHCALC})
 
         if(OpenMP_FOUND)
-            target_link_libraries(phphcalc_lib PRIVATE BLAS::BLAS LAPACK::LAPACK
-                                                       OpenMP::OpenMP_C)
+            target_link_libraries(
+                phphcalc_lib PRIVATE recgrid_lib BLAS::BLAS LAPACK::LAPACK
+                                     OpenMP::OpenMP_C)
         else()
-            target_link_libraries(phphcalc_lib PRIVATE BLAS::BLAS LAPACK::LAPACK)
+            target_link_libraries(phphcalc_lib PRIVATE recgrid_lib BLAS::BLAS
+                                                       LAPACK::LAPACK)
         endif()
 
         target_include_directories(phphcalc_lib PRIVATE ${MY_INCLUDES})
@@ -188,10 +225,10 @@ if(BUILD_PHPHCALC_LIB OR BUILD_NANOBIND_MODULE)
         add_library(phphcalc_lib STATIC ${SOURCES_PHPHCALC})
 
         if(OpenMP_FOUND)
-            target_link_libraries(phphcalc_lib BLAS::BLAS LAPACK::LAPACK
+            target_link_libraries(phphcalc_lib recgrid_lib BLAS::BLAS LAPACK::LAPACK
                                   OpenMP::OpenMP_C)
         else()
-            target_link_libraries(phphcalc_lib BLAS::BLAS LAPACK::LAPACK)
+            target_link_libraries(phphcalc_lib recgrid_lib BLAS::BLAS LAPACK::LAPACK)
         endif()
 
         target_include_directories(phphcalc_lib PRIVATE ${MY_INCLUDES})
@@ -236,7 +273,7 @@ if(BUILD_PHPHCALC_LIB OR BUILD_NANOBIND_MODULE)
 endif()
 
 # ###################################################################################
-# phononcalc #
+# Phonon calculation library #
 # ###################################################################################
 if(BUILD_PHONONCALC_LIB OR BUILD_NANOBIND_MODULE)
     # Source code
@@ -311,7 +348,7 @@ if(BUILD_PHONONCALC_LIB OR BUILD_NANOBIND_MODULE)
 endif()
 
 # ###################################################################################
-# grid #
+# gridsys #
 # ###################################################################################
 if(BUILD_GRIDSYS_LIB)
     # Source code
@@ -321,7 +358,7 @@ if(BUILD_GRIDSYS_LIB)
         ${PROJECT_SOURCE_DIR}/c/gridsys.c
         ${PROJECT_SOURCE_DIR}/c/lagrid.c
         ${PROJECT_SOURCE_DIR}/c/niggli.c
-        ${PROJECT_SOURCE_DIR}/c/phonoc_utils.c
+        ${PROJECT_SOURCE_DIR}/c/funcs.c
         ${PROJECT_SOURCE_DIR}/c/snf3x3.c
         ${PROJECT_SOURCE_DIR}/c/tetrahedron_method.c
         ${PROJECT_SOURCE_DIR}/c/triplet.c
@@ -388,11 +425,15 @@ if(BUILD_NANOBIND_MODULE)
                         ${PROJECT_SOURCE_DIR}/c/_phono3py.cpp)
     nanobind_add_module(_phononcalc STABLE_ABI ${PROJECT_SOURCE_DIR}/c/phononcalc.h
                         ${PROJECT_SOURCE_DIR}/c/_phononcalc.cpp)
+    nanobind_add_module(_recgrid STABLE_ABI ${PROJECT_SOURCE_DIR}/c/recgrid.h
+                        ${PROJECT_SOURCE_DIR}/c/_recgrid.cpp)
 
     target_link_libraries(_phono3py PRIVATE phphcalc_lib)
     target_link_libraries(_phononcalc PRIVATE phononcalc_lib)
+    target_link_libraries(_recgrid PRIVATE recgrid_lib)
 
     target_compile_definitions(_phono3py PRIVATE THM_EPSILON=1e-10)
     install(TARGETS _phono3py LIBRARY DESTINATION ${SKBUILD_PROJECT_NAME})
     install(TARGETS _phononcalc LIBRARY DESTINATION ${SKBUILD_PROJECT_NAME})
+    install(TARGETS _recgrid LIBRARY DESTINATION ${SKBUILD_PROJECT_NAME})
 endif()

{phono3py-3.3.0 → phono3py-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: phono3py
-Version: 3.3.0
+Version: 3.3.2
 Summary: This is the phono3py module.
 Author-Email: Atsushi Togo <atztogo@gmail.com>
 License: Copyright (c) 2015-2024, Phonopy. All rights reserved.

{phono3py-3.3.0 → phono3py-3.3.2}/c/_phono3py.cpp

@@ -1179,14 +1179,6 @@ NB_MODULE(_phono3py, m) {
     m.def("triplets_integration_weights", &py_get_triplets_integration_weights);
     m.def("triplets_integration_weights_with_sigma",
           &py_get_triplets_integration_weights_with_sigma);
-    m.def("grid_index_from_address", &py_get_grid_index_from_address);
-    m.def("ir_grid_map", &py_get_ir_grid_map);
-    m.def("gr_grid_addresses", &py_get_gr_grid_addresses);
-    m.def("reciprocal_rotations", &py_get_reciprocal_rotations);
-    m.def("transform_rotations", &py_transform_rotations);
-    m.def("snf3x3", &py_get_snf3x3);
-    m.def("bz_grid_addresses", &py_get_bz_grid_addresses);
-    m.def("rotate_bz_grid_index", &py_rotate_bz_grid_addresses);
     m.def("diagonalize_collision_matrix", &py_diagonalize_collision_matrix);
     m.def("pinv_from_eigensolution", &py_pinv_from_eigensolution);
     m.def("default_colmat_solver", &py_get_default_colmat_solver);

phono3py-3.3.2/c/_recgrid.cpp

@@ -0,0 +1,179 @@
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+
+#include "recgrid.h"
+
+namespace nb = nanobind;
+
+long py_get_grid_index_from_address(nb::ndarray<> py_address,
+                                    nb::ndarray<> py_D_diag) {
+    long *address;
+    long *D_diag;
+    long gp;
+
+    address = (long *)py_address.data();
+    D_diag = (long *)py_D_diag.data();
+
+    gp = recgrid_get_grid_index_from_address(address, D_diag);
+
+    return gp;
+}
+
+long py_get_ir_grid_map(nb::ndarray<> py_grid_mapping_table,
+                        nb::ndarray<> py_D_diag, nb::ndarray<> py_is_shift,
+                        nb::ndarray<> py_rotations) {
+    long *D_diag;
+    long *is_shift;
+    long(*rot)[3][3];
+    long num_rot;
+
+    long *grid_mapping_table;
+    long num_ir;
+
+    D_diag = (long *)py_D_diag.data();
+    is_shift = (long *)py_is_shift.data();
+    rot = (long(*)[3][3])py_rotations.data();
+    num_rot = (long)py_rotations.shape(0);
+    grid_mapping_table = (long *)py_grid_mapping_table.data();
+
+    num_ir = recgrid_get_ir_grid_map(grid_mapping_table, rot, num_rot, D_diag,
+                                     is_shift);
+    return num_ir;
+}
+
+void py_get_gr_grid_addresses(nb::ndarray<> py_gr_grid_addresses,
+                              nb::ndarray<> py_D_diag) {
+    long(*gr_grid_addresses)[3];
+    long *D_diag;
+
+    gr_grid_addresses = (long(*)[3])py_gr_grid_addresses.data();
+    D_diag = (long *)py_D_diag.data();
+
+    recgrid_get_all_grid_addresses(gr_grid_addresses, D_diag);
+}
+
+long py_get_reciprocal_rotations(nb::ndarray<> py_rec_rotations,
+                                 nb::ndarray<> py_rotations,
+                                 long is_time_reversal) {
+    long(*rec_rotations)[3][3];
+    long(*rotations)[3][3];
+    long num_rot, num_rec_rot;
+
+    rec_rotations = (long(*)[3][3])py_rec_rotations.data();
+    rotations = (long(*)[3][3])py_rotations.data();
+    num_rot = (long)py_rotations.shape(0);
+
+    num_rec_rot = recgrid_get_reciprocal_point_group(
+        rec_rotations, rotations, num_rot, is_time_reversal, 1);
+
+    return num_rec_rot;
+}
+
+bool py_transform_rotations(nb::ndarray<> py_transformed_rotations,
+                            nb::ndarray<> py_rotations, nb::ndarray<> py_D_diag,
+                            nb::ndarray<> py_Q) {
+    long(*transformed_rotations)[3][3];
+    long(*rotations)[3][3];
+    long *D_diag;
+    long(*Q)[3];
+    long num_rot, succeeded;
+
+    transformed_rotations = (long(*)[3][3])py_transformed_rotations.data();
+    rotations = (long(*)[3][3])py_rotations.data();
+    D_diag = (long *)py_D_diag.data();
+    Q = (long(*)[3])py_Q.data();
+    num_rot = (long)py_transformed_rotations.shape(0);
+
+    succeeded = recgrid_transform_rotations(transformed_rotations, rotations,
+                                            num_rot, D_diag, Q);
+    if (succeeded) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool py_get_snf3x3(nb::ndarray<> py_D_diag, nb::ndarray<> py_P,
+                   nb::ndarray<> py_Q, nb::ndarray<> py_A) {
+    long *D_diag;
+    long(*P)[3];
+    long(*Q)[3];
+    long(*A)[3];
+    long succeeded;
+
+    D_diag = (long *)py_D_diag.data();
+    P = (long(*)[3])py_P.data();
+    Q = (long(*)[3])py_Q.data();
+    A = (long(*)[3])py_A.data();
+
+    succeeded = recgrid_get_snf3x3(D_diag, P, Q, A);
+    if (succeeded) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+long py_get_bz_grid_addresses(nb::ndarray<> py_bz_grid_addresses,
+                              nb::ndarray<> py_bz_map, nb::ndarray<> py_bzg2grg,
+                              nb::ndarray<> py_D_diag, nb::ndarray<> py_Q,
+                              nb::ndarray<> py_PS,
+                              nb::ndarray<> py_reciprocal_lattice, long type) {
+    long(*bz_grid_addresses)[3];
+    long *bz_map;
+    long *bzg2grg;
+    long *D_diag;
+    long(*Q)[3];
+    long *PS;
+    double(*reciprocal_lattice)[3];
+    long num_total_gp;
+
+    bz_grid_addresses = (long(*)[3])py_bz_grid_addresses.data();
+    bz_map = (long *)py_bz_map.data();
+    bzg2grg = (long *)py_bzg2grg.data();
+    D_diag = (long *)py_D_diag.data();
+    Q = (long(*)[3])py_Q.data();
+    PS = (long *)py_PS.data();
+    reciprocal_lattice = (double(*)[3])py_reciprocal_lattice.data();
+
+    num_total_gp =
+        recgrid_get_bz_grid_addresses(bz_grid_addresses, bz_map, bzg2grg,
+                                      D_diag, Q, PS, reciprocal_lattice, type);
+
+    return num_total_gp;
+}
+
+long py_rotate_bz_grid_addresses(long bz_grid_index, nb::ndarray<> py_rotation,
+                                 nb::ndarray<> py_bz_grid_addresses,
+                                 nb::ndarray<> py_bz_map,
+                                 nb::ndarray<> py_D_diag, nb::ndarray<> py_PS,
+                                 long type) {
+    long(*bz_grid_addresses)[3];
+    long(*rotation)[3];
+    long *bz_map;
+    long *D_diag;
+    long *PS;
+    long ret_bz_gp;
+
+    bz_grid_addresses = (long(*)[3])py_bz_grid_addresses.data();
+    rotation = (long(*)[3])py_rotation.data();
+    bz_map = (long *)py_bz_map.data();
+    D_diag = (long *)py_D_diag.data();
+    PS = (long *)py_PS.data();
+
+    ret_bz_gp = recgrid_rotate_bz_grid_index(
+        bz_grid_index, rotation, bz_grid_addresses, bz_map, D_diag, PS, type);
+
+    return ret_bz_gp;
+}
+
+NB_MODULE(_recgrid, m) {
+    m.def("grid_index_from_address", &py_get_grid_index_from_address);
+    m.def("ir_grid_map", &py_get_ir_grid_map);
+    m.def("gr_grid_addresses", &py_get_gr_grid_addresses);
+    m.def("reciprocal_rotations", &py_get_reciprocal_rotations);
+    m.def("transform_rotations", &py_transform_rotations);
+    m.def("snf3x3", &py_get_snf3x3);
+    m.def("bz_grid_addresses", &py_get_bz_grid_addresses);
+    m.def("rotate_bz_grid_index", &py_rotate_bz_grid_addresses);
+}

{phono3py-3.3.0 → phono3py-3.3.2}/c/bzgrid.c

@@ -40,9 +40,9 @@
 
 #include "grgrid.h"
 #include "lagrid.h"
+#include "recgrid.h"
 
 #define BZG_NUM_BZ_SEARCH_SPACE 125
-#define GRID_TOLERANCE_FACTOR 0.01
 static long bz_search_space[BZG_NUM_BZ_SEARCH_SPACE][3] = {
     {0, 0, 0},   {0, 0, 1},   {0, 0, 2},   {0, 0, -2},   {0, 0, -1},
     {0, 1, 0},   {0, 1, 1},   {0, 1, 2},   {0, 1, -2},   {0, 1, -1},
@@ -70,21 +70,26 @@ static long bz_search_space[BZG_NUM_BZ_SEARCH_SPACE][3] = {
     {-1, -2, 0}, {-1, -2, 1}, {-1, -2, 2}, {-1, -2, -2}, {-1, -2, -1},
     {-1, -1, 0}, {-1, -1, 1}, {-1, -1, 2}, {-1, -1, -2}, {-1, -1, -1}};
 
-static void get_bz_grid_addresses_type1(BZGrid *bzgrid, const long Qinv[3][3]);
-static void get_bz_grid_addresses_type2(BZGrid *bzgrid, const long Qinv[3][3]);
+static void get_bz_grid_addresses_type1(RecgridBZGrid *bzgrid,
+                                        const long Qinv[3][3]);
+static void get_bz_grid_addresses_type2(RecgridBZGrid *bzgrid,
+                                        const long Qinv[3][3]);
 static void set_bz_address(long address[3], const long bz_index,
                            const long grid_address[3], const long D_diag[3],
                            const long nint[3], const long Qinv[3][3]);
 static double get_bz_distances(long nint[3], double distances[],
-                               const BZGrid *bzgrid, const long grid_address[3],
+                               const RecgridBZGrid *bzgrid,
+                               const long grid_address[3],
                                const double tolerance);
 static void multiply_matrix_vector_d3(double v[3], const double a[3][3],
                                       const double b[3]);
+static void multiply_matrix_vector_ld3(double v[3], const long a[3][3],
+                                       const double b[3]);
 static long get_inverse_unimodular_matrix_l3(long m[3][3], const long a[3][3]);
 static double norm_squared_d3(const double a[3]);
 
 long bzg_rotate_grid_index(const long bz_grid_index, const long rotation[3][3],
-                           const ConstBZGrid *bzgrid) {
+                           const RecgridConstBZGrid *bzgrid) {
     long i, gp, num_bzgp, num_grgp;
     long dadrs[3], dadrs_rot[3], adrs_rot[3];
 
@@ -124,7 +129,7 @@ long bzg_rotate_grid_index(const long bz_grid_index, const long rotation[3][3],
     return bzgrid->gp_map[gp];
 }
 
-long bzg_get_bz_grid_addresses(BZGrid *bzgrid) {
+long bzg_get_bz_grid_addresses(RecgridBZGrid *bzgrid) {
     long det;
     long Qinv[3][3];
 
@@ -142,91 +147,15 @@ long bzg_get_bz_grid_addresses(BZGrid *bzgrid) {
     return 1;
 }
 
-/* Note: Tolerance in squared distance. */
-double bzg_get_tolerance_for_BZ_reduction(const BZGrid *bzgrid) {
-    long i, j;
-    double tolerance;
-    double length[3];
-    double reclatQ[3][3];
-
-    for (i = 0; i < 3; i++) {
-        for (j = 0; j < 3; j++) {
-            reclatQ[i][j] = bzgrid->reclat[i][0] * bzgrid->Q[0][j] +
-                            bzgrid->reclat[i][1] * bzgrid->Q[1][j] +
-                            bzgrid->reclat[i][2] * bzgrid->Q[2][j];
-        }
-    }
-
-    for (i = 0; i < 3; i++) {
-        length[i] = 0;
-        for (j = 0; j < 3; j++) {
-            length[i] += reclatQ[j][i] * reclatQ[j][i];
-        }
-        length[i] /= bzgrid->D_diag[i] * bzgrid->D_diag[i];
-    }
-    tolerance = length[0];
-    for (i = 1; i < 3; i++) {
-        if (tolerance < length[i]) {
-            tolerance = length[i];
-        }
-    }
-    tolerance *= GRID_TOLERANCE_FACTOR;
-
-    return tolerance;
-}
-
-RotMats *bzg_alloc_RotMats(const long size) {
-    RotMats *rotmats;
-
-    rotmats = NULL;
-
-    if ((rotmats = (RotMats *)malloc(sizeof(RotMats))) == NULL) {
-        warning_print("Memory could not be allocated.");
-        return NULL;
-    }
-
-    rotmats->size = size;
-    if (size > 0) {
-        if ((rotmats->mat = (long(*)[3][3])malloc(sizeof(long[3][3]) * size)) ==
-            NULL) {
-            warning_print("Memory could not be allocated ");
-            warning_print("(RotMats, line %d, %s).\n", __LINE__, __FILE__);
-            free(rotmats);
-            rotmats = NULL;
-            return NULL;
-        }
-    }
-    return rotmats;
-}
-
-void bzg_free_RotMats(RotMats *rotmats) {
-    if (rotmats->size > 0) {
-        free(rotmats->mat);
-        rotmats->mat = NULL;
-    }
-    free(rotmats);
-}
-
-void bzg_multiply_matrix_vector_ld3(double v[3], const long a[3][3],
-                                    const double b[3]) {
-    long i;
-    double c[3];
-    for (i = 0; i < 3; i++) {
-        c[i] = a[i][0] * b[0] + a[i][1] * b[1] + a[i][2] * b[2];
-    }
-    for (i = 0; i < 3; i++) {
-        v[i] = c[i];
-    }
-}
-
-static void get_bz_grid_addresses_type1(BZGrid *bzgrid, const long Qinv[3][3]) {
+static void get_bz_grid_addresses_type1(RecgridBZGrid *bzgrid,
+                                        const long Qinv[3][3]) {
     double tolerance, min_distance;
     double distances[BZG_NUM_BZ_SEARCH_SPACE];
     long bzmesh[3], bz_address_double[3], nint[3], gr_adrs[3];
     long i, j, k, boundary_num_gp, total_num_gp, bzgp, gp, num_bzmesh;
     long count, id_shift;
 
-    tolerance = bzg_get_tolerance_for_BZ_reduction(bzgrid);
+    tolerance = recgrid_get_tolerance_for_BZ_reduction(bzgrid);
     for (j = 0; j < 3; j++) {
         bzmesh[j] = bzgrid->D_diag[j] * 2;
     }
@@ -278,13 +207,14 @@ static void get_bz_grid_addresses_type1(BZGrid *bzgrid, const long Qinv[3][3]) {
     bzgrid->size = boundary_num_gp + total_num_gp;
 }
 
-static void get_bz_grid_addresses_type2(BZGrid *bzgrid, const long Qinv[3][3]) {
+static void get_bz_grid_addresses_type2(RecgridBZGrid *bzgrid,
+                                        const long Qinv[3][3]) {
     double tolerance, min_distance;
     double distances[BZG_NUM_BZ_SEARCH_SPACE];
     long nint[3], gr_adrs[3];
     long i, j, num_gp;
 
-    tolerance = bzg_get_tolerance_for_BZ_reduction(bzgrid);
+    tolerance = recgrid_get_tolerance_for_BZ_reduction(bzgrid);
     num_gp = 0;
     /* The first element of gp_map is always 0. */
     bzgrid->gp_map[0] = 0;
@@ -324,7 +254,8 @@ static void set_bz_address(long address[3], const long bz_index,
 }
 
 static double get_bz_distances(long nint[3], double distances[],
-                               const BZGrid *bzgrid, const long grid_address[3],
+                               const RecgridBZGrid *bzgrid,
+                               const long grid_address[3],
                                const double tolerance) {
     long i, j;
     long dadrs[3];
@@ -336,7 +267,7 @@ static double get_bz_distances(long nint[3], double distances[],
     for (i = 0; i < 3; i++) {
         q_red[i] = dadrs[i] / (2.0 * bzgrid->D_diag[i]);
     }
-    bzg_multiply_matrix_vector_ld3(q_red, bzgrid->Q, q_red);
+    multiply_matrix_vector_ld3(q_red, bzgrid->Q, q_red);
     for (i = 0; i < 3; i++) {
         nint[i] = lagmat_Nint(q_red[i]);
         q_red[i] -= nint[i];
@@ -376,6 +307,18 @@ static void multiply_matrix_vector_d3(double v[3], const double a[3][3],
     }
 }
 
+static void multiply_matrix_vector_ld3(double v[3], const long a[3][3],
+                                       const double b[3]) {
+    long i;
+    double c[3];
+    for (i = 0; i < 3; i++) {
+        c[i] = a[i][0] * b[0] + a[i][1] * b[1] + a[i][2] * b[2];
+    }
+    for (i = 0; i < 3; i++) {
+        v[i] = c[i];
+    }
+}
+
 static long get_inverse_unimodular_matrix_l3(long m[3][3], const long a[3][3]) {
     long det;
     long c[3][3];

phono3py-3.3.2/c/bzgrid.h

@@ -0,0 +1,44 @@
+/* Copyright (C) 2008 Atsushi Togo */
+/* All rights reserved. */
+
+/* This file is part of spglib. */
+
+/* Redistribution and use in source and binary forms, with or without */
+/* modification, are permitted provided that the following conditions */
+/* are met: */
+
+/* * Redistributions of source code must retain the above copyright */
+/*   notice, this list of conditions and the following disclaimer. */
+
+/* * Redistributions in binary form must reproduce the above copyright */
+/*   notice, this list of conditions and the following disclaimer in */
+/*   the documentation and/or other materials provided with the */
+/*   distribution. */
+
+/* * Neither the name of the phonopy project nor the names of its */
+/*   contributors may be used to endorse or promote products derived */
+/*   from this software without specific prior written permission. */
+
+/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */
+/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */
+/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */
+/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE */
+/* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, */
+/* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, */
+/* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; */
+/* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER */
+/* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT */
+/* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN */
+/* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE */
+/* POSSIBILITY OF SUCH DAMAGE. */
+
+#ifndef __bzgrid_H__
+#define __bzgrid_H__
+
+#include "recgrid.h"
+
+long bzg_rotate_grid_index(const long grid_index, const long rotation[3][3],
+                           const RecgridConstBZGrid *bzgrid);
+long bzg_get_bz_grid_addresses(RecgridBZGrid *bzgrid);
+
+#endif

{phono3py-3.3.0 → phono3py-3.3.2}/c/collision_matrix.c

@@ -38,8 +38,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include "funcs.h"
 #include "phonoc_array.h"
-#include "phonoc_utils.h"
 
 static void get_collision_matrix(
     double *collision_matrix, const double *fc3_normal_squared,
@@ -255,7 +255,7 @@ static long get_inv_sinh(double *inv_sinh, const long gp,
     for (i = 0; i < num_band; i++) {
         f = frequencies[gp2 * num_band + i];
         if (f > cutoff_frequency) {
-            inv_sinh[i] = phonoc_inv_sinh_occupation(f, temperature);
+            inv_sinh[i] = funcs_inv_sinh_occupation(f, temperature);
         } else {
             inv_sinh[i] = 0;
         }