Upload 845 files

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+phonopy/source/doc/Al-QHA.png filter=lfs diff=lfs merge=lfs -text
+phonopy/source/doc/band.png filter=lfs diff=lfs merge=lfs -text
+phonopy/source/doc/pdos.png filter=lfs diff=lfs merge=lfs -text
+phonopy/source/doc/QHA.png filter=lfs diff=lfs merge=lfs -text
+phonopy/source/doc/thermalprop.png filter=lfs diff=lfs merge=lfs -text
+phonopy/source/doc/Ubuntu-install.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10
+
+RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
+
+EXPOSE 7860
+
+CMD ["python", "phonopy/mcp_output/start_mcp.py"]

README.md

@@ -1,10 +1,32 @@
 ---
-title: Phonopy
-emoji: 🐠
-colorFrom: green
-colorTo: gray
+title: Phonopy MCP
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
 sdk: docker
+sdk_version: "4.26.0"
+app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Phonopy MCP Service
+
+Auto-generated MCP service for phonopy.
+
+## Usage
+
+```
+https://None-phonopy-mcp.hf.space/mcp
+```
+
+## Connect with Cursor
+
+```json
+{
+  "mcpServers": {
+    "phonopy": {
+      "url": "https://None-phonopy-mcp.hf.space/mcp"
+    }
+  }
+}
+```

app.py

@@ -0,0 +1,45 @@
+from fastapi import FastAPI
+import os
+import sys
+
+mcp_plugin_path = os.path.join(os.path.dirname(__file__), "phonopy", "mcp_output", "mcp_plugin")
+sys.path.insert(0, mcp_plugin_path)
+
+app = FastAPI(
+    title="Phonopy MCP Service",
+    description="Auto-generated MCP service for phonopy",
+    version="1.0.0"
+)
+
+@app.get("/")
+def root():
+    return {
+        "service": "Phonopy MCP Service",
+        "version": "1.0.0",
+        "status": "running",
+        "transport": os.environ.get("MCP_TRANSPORT", "http")
+    }
+
+@app.get("/health")
+def health_check():
+    return {"status": "healthy", "service": "phonopy MCP"}
+
+@app.get("/tools")
+def list_tools():
+    try:
+        from mcp_service import create_app
+        mcp_app = create_app()
+        tools = []
+        for tool_name, tool_func in mcp_app.tools.items():
+            tools.append({
+                "name": tool_name,
+                "description": tool_func.__doc__ or "No description available"
+            })
+        return {"tools": tools}
+    except Exception as e:
+        return {"error": f"Failed to load tools: {str(e)}"}
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

phonopy/mcp_output/README_MCP.md

@@ -0,0 +1,51 @@
+# Phonopy MCP (Model Context Protocol) Service
+
+## Project Introduction
+
+Phonopy is a Python package designed for phonon calculations in the harmonic approximation. It is used to compute phonon frequencies, band structures, density of states, and thermodynamic properties by solving the lattice dynamics eigenvalue problem from interatomic force constants. Phonopy supports a wide range of calculator interfaces and file formats, making it a versatile tool for researchers and developers working with crystal structures and atomic forces.
+
+## Installation Method
+
+To install Phonopy, ensure you have the following dependencies: `numpy`, `scipy`, and `matplotlib`. Optionally, you can also install `ase` and `spglib` for additional functionalities.
+
+You can install Phonopy using pip:
+
+```
+pip install phonopy
+```
+
+## Quick Start
+
+To quickly get started with Phonopy, you can use the following example to perform basic phonon calculations:
+
+1. Import the Phonopy class and create an instance:
+   - `from phonopy import Phonopy`
+   - `phonopy_instance = Phonopy(unitcell, supercell_matrix)`
+
+2. Generate displacements:
+   - `phonopy_instance.generate_displacements()`
+
+3. Calculate force constants:
+   - `phonopy_instance.produce_force_constants()`
+
+4. Run phonon band structure calculations:
+   - `phonopy_instance.run_band_structure()`
+
+5. Compute thermal properties:
+   - `phonopy_instance.run_thermal_properties()`
+
+## Available Tools and Endpoints List
+
+- **Phonopy CLI**: Main command-line interface for phonon calculations.
+- **Phonopy-bandplot**: Tool for plotting phonon band structures.
+- **Phonopy-gruneisen**: Tool for Gruneisen parameter calculations.
+
+## Common Issues and Notes
+
+- Ensure all dependencies are correctly installed to avoid import errors.
+- The performance of calculations can vary based on the complexity of the crystal structures and the computational resources available.
+- For large-scale calculations, consider using optimized computational resources to improve performance.
+
+## Reference Links or Documentation
+
+For more detailed information, please refer to the [Phonopy GitHub Repository](https://github.com/phonopy/phonopy) and the official documentation available within the repository. This includes comprehensive guides on installation, usage, and advanced topics related to phonon calculations.

phonopy/mcp_output/analysis.json

@@ -0,0 +1,1051 @@
+{
+  "summary": {
+    "repository_url": "https://github.com/phonopy/phonopy",
+    "summary": "Imported via zip fallback, file count: 310",
+    "file_tree": {
+      ".github/workflows/phonopy-pytest-conda.yml": {
+        "size": 1253
+      },
+      ".github/workflows/phonopy-pytest-pip-windows-macos.yml": {
+        "size": 962
+      },
+      ".github/workflows/publish-gh-pages.yml": {
+        "size": 1145
+      },
+      ".github/workflows/publish-to-test-pypi.yml": {
+        "size": 1135
+      },
+      ".github/workflows/wheels.yml": {
+        "size": 2913
+      },
+      ".pre-commit-config.yaml": {
+        "size": 641
+      },
+      "CMakeLists.txt": {
+        "size": 4139
+      },
+      "README.md": {
+        "size": 2421
+      },
+      "cmake-format.py": {
+        "size": 81
+      },
+      "dev-requirements.txt": {
+        "size": 6
+      },
+      "doc/README.md": {
+        "size": 798
+      },
+      "doc/animation.md": {
+        "size": 1359
+      },
+      "doc/auxiliary-tools.md": {
+        "size": 2420
+      },
+      "doc/changelog.md": {
+        "size": 50169
+      },
+      "doc/citation.md": {
+        "size": 3797
+      },
+      "doc/command-options.md": {
+        "size": 15498
+      },
+      "doc/conf.py": {
+        "size": 9301
+      },
+      "doc/documentation.md": {
+        "size": 292
+      },
+      "doc/dynamic-structure-factor.md": {
+        "size": 8729
+      },
+      "doc/examples.md": {
+        "size": 16429
+      },
+      "doc/external-tools.md": {
+        "size": 2378
+      },
+      "doc/formulation.md": {
+        "size": 21886
+      },
+      "doc/gruneisen.md": {
+        "size": 4671
+      },
+      "doc/index.md": {
+        "size": 3354
+      },
+      "doc/input-files.md": {
+        "size": 18032
+      },
+      "doc/install.md": {
+        "size": 6604
+      },
+      "doc/interfaces.md": {
+        "size": 4756
+      },
+      "doc/lammps.md": {
+        "size": 7422
+      },
+      "doc/mlp-sscha.md": {
+        "size": 22878
+      },
+      "doc/output-files.md": {
+        "size": 8411
+      },
+      "doc/phonopy-load.md": {
+        "size": 2601
+      },
+      "doc/phonopy-module.md": {
+        "size": 25291
+      },
+      "doc/phonopy-yaml.md": {
+        "size": 1363
+      },
+      "doc/qe.md": {
+        "size": 11122
+      },
+      "doc/qha.md": {
+        "size": 10044
+      },
+      "doc/qlm.md": {
+        "size": 2047
+      },
+      "doc/random-displacements.md": {
+        "size": 8990
+      },
+      "doc/reference.md": {
+        "size": 7384
+      },
+      "doc/setting-tags.md": {
+        "size": 50129
+      },
+      "doc/symmetry.md": {
+        "size": 2389
+      },
+      "doc/vasp-dfpt.md": {
+        "size": 4022
+      },
+      "doc/vasp.md": {
+        "size": 5280
+      },
+      "doc/workflow.md": {
+        "size": 1017
+      },
+      "example/Al-ABACUS/abacus-lcao/band.yaml": {
+        "size": 63428
+      },
+      "example/Al-ABACUS/abacus-lcao/mesh.yaml": {
+        "size": 14819
+      },
+      "example/Al-ABACUS/abacus-lcao/phonopy.yaml": {
+        "size": 8206
+      },
+      "example/Al-ABACUS/abacus-lcao/phonopy_disp.yaml": {
+        "size": 8425
+      },
+      "example/Al-ABACUS/abacus-pw/band.yaml": {
+        "size": 63428
+      },
+      "example/Al-ABACUS/abacus-pw/mesh.yaml": {
+        "size": 14819
+      },
+      "example/Al-ABACUS/abacus-pw/phonopy.yaml": {
+        "size": 8206
+      },
+      "example/Al-ABACUS/abacus-pw/phonopy_disp.yaml": {
+        "size": 8425
+      },
+      "example/Al-Fleur/phonopy_disp.yaml": {
+        "size": 3028
+      },
+      "example/Al-QHA/Al-QHA.py": {
+        "size": 1366
+      },
+      "example/Al2O3/Al2O3.py": {
+        "size": 1374
+      },
+      "example/Al2O3/README.md": {
+        "size": 634
+      },
+      "example/Al2O3/phonopy_disp.yaml": {
+        "size": 26770
+      },
+      "example/CaTiO3/phonopy_disp.yaml": {
+        "size": 8808
+      },
+      "example/Cr/README.md": {
+        "size": 1049
+      },
+      "example/Cr/phonopy_disp.yaml": {
+        "size": 5130
+      },
+      "example/KCl-SSCHA/README.md": {
+        "size": 3227
+      },
+      "example/KCl-SSCHA/embed_sscha_fc.py": {
+        "size": 1069
+      },
+      "example/LiF-nosym/README.md": {
+        "size": 561
+      },
+      "example/MgB2/MgB2.py": {
+        "size": 593
+      },
+      "example/MgB2/README.md": {
+        "size": 393
+      },
+      "example/MgB2/phonopy_disp.yaml": {
+        "size": 9982
+      },
+      "example/MgO/README.md": {
+        "size": 311
+      },
+      "example/MgO/phonopy_disp.yaml": {
+        "size": 12692
+      },
+      "example/NaCl-CP2K/README.md": {
+        "size": 989
+      },
+      "example/NaCl-CP2K/phonopy_disp.yaml": {
+        "size": 12733
+      },
+      "example/NaCl-QE-q2r/make_born_q2r.py": {
+        "size": 723
+      },
+      "example/NaCl-QE-q2r/make_fc_q2r.py": {
+        "size": 308
+      },
+      "example/NaCl-QE/README.md": {
+        "size": 1335
+      },
+      "example/NaCl-QE/phonopy_disp.yaml": {
+        "size": 12219
+      },
+      "example/NaCl-VASPdfpt/README.md": {
+        "size": 580
+      },
+      "example/NaCl-abinit/disp.yaml": {
+        "size": 6433
+      },
+      "example/NaCl-rd/README.md": {
+        "size": 733
+      },
+      "example/NaCl-rd/phonopy_disp.yaml": {
+        "size": 73476
+      },
+      "example/NaCl-wien2k-P1/README.md": {
+        "size": 602
+      },
+      "example/NaCl-wien2k-P1/phonopy_disp.yaml": {
+        "size": 12207
+      },
+      "example/NaCl-wien2k/README.md": {
+        "size": 519
+      },
+      "example/NaCl-wien2k/phonopy_disp.yaml": {
+        "size": 12207
+      },
+      "example/NaCl/NaCl-band-gv.py": {
+        "size": 1132
+      },
+      "example/NaCl/NaCl-band.py": {
+        "size": 586
+      },
+      "example/NaCl/NaCl-dynmat.py": {
+        "size": 1100
+      },
+      "example/NaCl/NaCl-gv.py": {
+        "size": 814
+      },
+      "example/NaCl/NaCl-read_write_fc.py": {
+        "size": 670
+      },
+      "example/NaCl/NaCl-yaml.py": {
+        "size": 502
+      },
+      "example/NaCl/NaCl.py": {
+        "size": 4078
+      },
+      "example/NaCl/README.md": {
+        "size": 872
+      },
+      "example/NaCl/phonopy_disp.yaml": {
+        "size": 12203
+      },
+      "example/Si-CP2K/README.md": {
+        "size": 833
+      },
+      "example/Si-PWmat/README.md": {
+        "size": 900
+      },
+      "example/Si-PWmat/mesh.yaml": {
+        "size": 291996
+      },
+      "example/Si-QE/README.md": {
+        "size": 773
+      },
+      "example/Si-QE/phonopy_disp.yaml": {
+        "size": 12097
+      },
+      "example/Si-QHA/Si.py": {
+        "size": 2003
+      },
+      "example/Si-QHA/disp.yaml": {
+        "size": 211
+      },
+      "example/Si-abinit/disp.yaml": {
+        "size": 6249
+      },
+      "example/Si-elk/disp.yaml": {
+        "size": 6249
+      },
+      "example/Si-gruneisen/Si-gruneisen.py": {
+        "size": 1980
+      },
+      "example/Si-gruneisen/minus/disp.yaml": {
+        "size": 6249
+      },
+      "example/Si-gruneisen/orig/disp.yaml": {
+        "size": 6249
+      },
+      "example/Si-gruneisen/plus/disp.yaml": {
+        "size": 6249
+      },
+      "example/Si-lammps/README.md": {
+        "size": 2510
+      },
+      "example/Si-lammps/generate_displacements.py": {
+        "size": 551
+      },
+      "example/Si-lammps/phonopy_disp.yaml": {
+        "size": 4427
+      },
+      "example/Si-lammps/phonopy_unitcell.yaml": {
+        "size": 432
+      },
+      "example/Si-nosym/disp.yaml": {
+        "size": 4301
+      },
+      "example/Si/README.md": {
+        "size": 529
+      },
+      "example/Si/phonopy_disp.yaml": {
+        "size": 4592
+      },
+      "example/SiO2-CP2K-xyz/README.md": {
+        "size": 1472
+      },
+      "example/SiO2-CP2K-xyz/gen_supercell_xyz.py": {
+        "size": 6490
+      },
+      "example/SiO2-CP2K-xyz/get_born_cp2k.py": {
+        "size": 8020
+      },
+      "example/SiO2-HP/README.md": {
+        "size": 730
+      },
+      "example/SiO2-HP/phonopy_disp.yaml": {
+        "size": 10059
+      },
+      "example/SnO2/README.md": {
+        "size": 1036
+      },
+      "example/SnO2/phonopy_disp.yaml": {
+        "size": 13427
+      },
+      "example/Ti-lammps/README.md": {
+        "size": 2715
+      },
+      "example/Ti-lammps/phonopy_disp.yaml": {
+        "size": 15528
+      },
+      "example/TiO2-anatase/README.md": {
+        "size": 293
+      },
+      "example/TiO2-anatase/phonopy_disp.yaml": {
+        "size": 31890
+      },
+      "example/ZnO/README.md": {
+        "size": 224
+      },
+      "example/ZnO/phonopy_disp.yaml": {
+        "size": 7641
+      },
+      "example/diamond-FHI-aims/README.md": {
+        "size": 818
+      },
+      "phonopy/__init__.py": {
+        "size": 1907
+      },
+      "phonopy/api_gruneisen.py": {
+        "size": 7884
+      },
+      "phonopy/api_phonopy.py": {
+        "size": 134219
+      },
+      "phonopy/api_qha.py": {
+        "size": 17431
+      },
+      "phonopy/cui/collect_cell_info.py": {
+        "size": 20559
+      },
+      "phonopy/cui/create_force_sets.py": {
+        "size": 10783
+      },
+      "phonopy/cui/load.py": {
+        "size": 14364
+      },
+      "phonopy/cui/load_helper.py": {
+        "size": 19077
+      },
+      "phonopy/cui/phonopy_argparse.py": {
+        "size": 28408
+      },
+      "phonopy/cui/phonopy_bandplot_script.py": {
+        "size": 19662
+      },
+      "phonopy/cui/phonopy_gruneisen_script.py": {
+        "size": 14439
+      },
+      "phonopy/cui/phonopy_qha_script.py": {
+        "size": 12066
+      },
+      "phonopy/cui/phonopy_script.py": {
+        "size": 80359
+      },
+      "phonopy/cui/phonopy_vasp_efe_script.py": {
+        "size": 5780
+      },
+      "phonopy/cui/settings.py": {
+        "size": 81854
+      },
+      "phonopy/cui/show_symmetry.py": {
+        "size": 8377
+      },
+      "phonopy/exception.py": {
+        "size": 2814
+      },
+      "phonopy/file_IO.py": {
+        "size": 30976
+      },
+      "phonopy/gruneisen/band_structure.py": {
+        "size": 11360
+      },
+      "phonopy/gruneisen/core.py": {
+        "size": 5836
+      },
+      "phonopy/gruneisen/mesh.py": {
+        "size": 8790
+      },
+      "phonopy/harmonic/derivative_dynmat.py": {
+        "size": 12781
+      },
+      "phonopy/harmonic/displacement.py": {
+        "size": 11529
+      },
+      "phonopy/harmonic/dynamical_matrix.py": {
+        "size": 39772
+      },
+      "phonopy/harmonic/dynmat_to_fc.py": {
+        "size": 17407
+      },
+      "phonopy/harmonic/force_constants.py": {
+        "size": 29448
+      },
+      "phonopy/interface/abacus.py": {
+        "size": 13287
+      },
+      "phonopy/interface/abinit.py": {
+        "size": 9781
+      },
+      "phonopy/interface/aims.py": {
+        "size": 7935
+      },
+      "phonopy/interface/alm.py": {
+        "size": 13943
+      },
+      "phonopy/interface/calculator.py": {
+        "size": 40720
+      },
+      "phonopy/interface/castep.py": {
+        "size": 9449
+      },
+      "phonopy/interface/cif.py": {
+        "size": 3820
+      },
+      "phonopy/interface/cp2k.py": {
+        "size": 14478
+      },
+      "phonopy/interface/crystal.py": {
+        "size": 14085
+      },
+      "phonopy/interface/dftbp.py": {
+        "size": 6674
+      },
+      "phonopy/interface/elk.py": {
+        "size": 7589
+      },
+      "phonopy/interface/fc_calculator.py": {
+        "size": 12689
+      },
+      "phonopy/interface/fleur.py": {
+        "size": 10058
+      },
+      "phonopy/interface/lammps.py": {
+        "size": 13809
+      },
+      "phonopy/interface/mlp.py": {
+        "size": 3421
+      },
+      "phonopy/interface/phonopy_yaml.py": {
+        "size": 42053
+      },
+      "phonopy/interface/pwmat.py": {
+        "size": 5803
+      },
+      "phonopy/interface/pypolymlp.py": {
+        "size": 15197
+      },
+      "phonopy/interface/qe.py": {
+        "size": 24153
+      },
+      "phonopy/interface/qlm.py": {
+        "size": 6874
+      },
+      "phonopy/interface/siesta.py": {
+        "size": 9549
+      },
+      "phonopy/interface/symfc.py": {
+        "size": 16920
+      },
+      "phonopy/interface/turbomole.py": {
+        "size": 8835
+      },
+      "phonopy/interface/vasp.py": {
+        "size": 57527
+      },
+      "phonopy/interface/wien2k.py": {
+        "size": 14256
+      },
+      "phonopy/phonon/animation.py": {
+        "size": 12257
+      },
+      "phonopy/phonon/band_structure.py": {
+        "size": 36609
+      },
+      "phonopy/phonon/character_table.py": {
+        "size": 42462
+      },
+      "phonopy/phonon/degeneracy.py": {
+        "size": 5702
+      },
+      "phonopy/phonon/dos.py": {
+        "size": 20985
+      },
+      "phonopy/phonon/group_velocity.py": {
+        "size": 11359
+      },
+      "phonopy/phonon/irreps.py": {
+        "size": 26033
+      },
+      "phonopy/phonon/mesh.py": {
+        "size": 16041
+      },
+      "phonopy/phonon/modulation.py": {
+        "size": 11866
+      },
+      "phonopy/phonon/moment.py": {
+        "size": 4214
+      },
+      "phonopy/phonon/qpoints.py": {
+        "size": 10579
+      },
+      "phonopy/phonon/random_displacements.py": {
+        "size": 21609
+      },
+      "phonopy/phonon/tetrahedron_mesh.py": {
+        "size": 10236
+      },
+      "phonopy/phonon/thermal_displacement.py": {
+        "size": 17368
+      },
+      "phonopy/phonon/thermal_properties.py": {
+        "size": 24661
+      },
+      "phonopy/physical_units.py": {
+        "size": 7741
+      },
+      "phonopy/qha/core.py": {
+        "size": 42678
+      },
+      "phonopy/qha/electron.py": {
+        "size": 7371
+      },
+      "phonopy/qha/eos.py": {
+        "size": 4712
+      },
+      "phonopy/scripts/phonopy.py": {
+        "size": 1765
+      },
+      "phonopy/scripts/phonopy_bandplot.py": {
+        "size": 1695
+      },
+      "phonopy/scripts/phonopy_calc_convert.py": {
+        "size": 8279
+      },
+      "phonopy/scripts/phonopy_crystal_born.py": {
+        "size": 5781
+      },
+      "phonopy/scripts/phonopy_gruneisen.py": {
+        "size": 1697
+      },
+      "phonopy/scripts/phonopy_gruneisenplot.py": {
+        "size": 9210
+      },
+      "phonopy/scripts/phonopy_load.py": {
+        "size": 1792
+      },
+      "phonopy/scripts/phonopy_pdosplot.py": {
+        "size": 6975
+      },
+      "phonopy/scripts/phonopy_propplot.py": {
+        "size": 7263
+      },
+      "phonopy/scripts/phonopy_qe_born.py": {
+        "size": 5333
+      },
+      "phonopy/scripts/phonopy_qha.py": {
+        "size": 1685
+      },
+      "phonopy/scripts/phonopy_tdplot.py": {
+        "size": 7327
+      },
+      "phonopy/scripts/phonopy_vasp_born.py": {
+        "size": 5983
+      },
+      "phonopy/scripts/phonopy_vasp_efe.py": {
+        "size": 1696
+      },
+      "phonopy/spectrum/dynamic_structure_factor.py": {
+        "size": 11697
+      },
+      "phonopy/spectrum/velocity.py": {
+        "size": 7807
+      },
+      "phonopy/sscha/core.py": {
+        "size": 8404
+      },
+      "phonopy/structure/atoms.py": {
+        "size": 43239
+      },
+      "phonopy/structure/brillouin_zone.py": {
+        "size": 5659
+      },
+      "phonopy/structure/cells.py": {
+        "size": 61680
+      },
+      "phonopy/structure/dataset.py": {
+        "size": 3848
+      },
+      "phonopy/structure/grid_points.py": {
+        "size": 24021
+      },
+      "phonopy/structure/snf.py": {
+        "size": 11479
+      },
+      "phonopy/structure/symmetry.py": {
+        "size": 23251
+      },
+      "phonopy/structure/tetrahedron_method.py": {
+        "size": 23214
+      },
+      "phonopy/unfolding/core.py": {
+        "size": 14179
+      },
+      "phonopy/units.py": {
+        "size": 3770
+      },
+      "phonopy/utils.py": {
+        "size": 2433
+      },
+      "phonopy/version.py": {
+        "size": 1641
+      },
+      "pyproject.toml": {
+        "size": 2448
+      },
+      "requirements.txt": {
+        "size": 76
+      },
+      "test/api/test_api_phonopy.py": {
+        "size": 14759
+      },
+      "test/conftest.py": {
+        "size": 17038
+      },
+      "test/cui/phonopy_command/test_phonopy_script.py": {
+        "size": 26894
+      },
+      "test/cui/phonopy_gruneisen/test_phonopy_gruneisen_script.py": {
+        "size": 3395
+      },
+      "test/cui/phonopy_qha/test_phonopy_qha_script.py": {
+        "size": 4923
+      },
+      "test/cui/phonopy_vasp_efe/test_phonopy_vasp_efe_script.py": {
+        "size": 1707
+      },
+      "test/gruneisen/test_gruneisen.py": {
+        "size": 5051
+      },
+      "test/harmonic/test_derivative_dynmat.py": {
+        "size": 3866
+      },
+      "test/harmonic/test_displacements.py": {
+        "size": 9356
+      },
+      "test/harmonic/test_dynamical_matrix.py": {
+        "size": 26441
+      },
+      "test/harmonic/test_dynmat_to_fc.py": {
+        "size": 5222
+      },
+      "test/harmonic/test_force_constants.py": {
+        "size": 4757
+      },
+      "test/interface/BaGa2-wien2k.yaml": {
+        "size": 591
+      },
+      "test/interface/NaCl-abacus-mag-noncolin.yaml": {
+        "size": 17712
+      },
+      "test/interface/NaCl-abacus-mag.yaml": {
+        "size": 15189
+      },
+      "test/interface/NaCl-abinit-pwscf.yaml": {
+        "size": 1155
+      },
+      "test/interface/NaCl-castep.yaml": {
+        "size": 1152
+      },
+      "test/interface/NaCl-vasp.yaml": {
+        "size": 1155
+      },
+      "test/interface/Si-CP2K.yaml": {
+        "size": 1155
+      },
+      "test/interface/Si-CRYSTAL.yaml": {
+        "size": 477
+      },
+      "test/interface/Si-TURBOMOLE.yaml": {
+        "size": 1155
+      },
+      "test/interface/Si-pwmat.yaml": {
+        "size": 14460
+      },
+      "test/interface/nac.yaml": {
+        "size": 780
+      },
+      "test/interface/phonopy.yaml": {
+        "size": 12534
+      },
+      "test/interface/phonopy_symcells_NaCl.yaml": {
+        "size": 1739
+      },
+      "test/interface/test_CP2K.py": {
+        "size": 968
+      },
+      "test/interface/test_CRYSTAL.py": {
+        "size": 770
+      },
+      "test/interface/test_TURBOMOLE.py": {
+        "size": 774
+      },
+      "test/interface/test_abacus.py": {
+        "size": 3247
+      },
+      "test/interface/test_abinit.py": {
+        "size": 1004
+      },
+      "test/interface/test_castep.py": {
+        "size": 757
+      },
+      "test/interface/test_conversion.py": {
+        "size": 3861
+      },
+      "test/interface/test_lammps.py": {
+        "size": 3567
+      },
+      "test/interface/test_phonopy_yaml.py": {
+        "size": 7596
+      },
+      "test/interface/test_pwmat.py": {
+        "size": 1143
+      },
+      "test/interface/test_pypolymlp.py": {
+        "size": 14419
+      },
+      "test/interface/test_qe.py": {
+        "size": 3427
+      },
+      "test/interface/test_qlm.py": {
+        "size": 2388
+      },
+      "test/interface/test_symfc.py": {
+        "size": 2916
+      },
+      "test/interface/test_vasp.py": {
+        "size": 7703
+      },
+      "test/interface/test_wien2k.py": {
+        "size": 813
+      },
+      "test/phonon/eigvecs_ii_TiPN3.txt": {
+        "size": 22923
+      },
+      "test/phonon/eigvecs_ij_TiPN3.txt": {
+        "size": 73570
+      },
+      "test/phonon/test_band_structure.py": {
+        "size": 7145
+      },
+      "test/phonon/test_dos.py": {
+        "size": 4028
+      },
+      "test/phonon/test_group_velocity.py": {
+        "size": 2563
+      },
+      "test/phonon/test_irreps.py": {
+        "size": 63607
+      },
+      "test/phonon/test_mesh.py": {
+        "size": 6271
+      },
+      "test/phonon/test_modulation.py": {
+        "size": 1621
+      },
+      "test/phonon/test_moment.py": {
+        "size": 1831
+      },
+      "test/phonon/test_qpoints.py": {
+        "size": 3955
+      },
+      "test/phonon/test_random_displacements.py": {
+        "size": 19456
+      },
+      "test/phonon/test_tetrahedron_mesh.py": {
+        "size": 2896
+      },
+      "test/phonon/test_thermal_displacement.py": {
+        "size": 6109
+      },
+      "test/phonon/test_thermal_properties.py": {
+        "size": 1775
+      },
+      "test/phonon/test_thermal_properties_classical.py": {
+        "size": 1832
+      },
+      "test/phonopy_KCl.yaml": {
+        "size": 12596
+      },
+      "test/phonopy_NaCl_unitcell1.yaml": {
+        "size": 1184
+      },
+      "test/phonopy_NaCl_unitcell2.yaml": {
+        "size": 1152
+      },
+      "test/phonopy_disp_NaCl.yaml": {
+        "size": 12203
+      },
+      "test/phonopy_disp_SnO2.yaml": {
+        "size": 13647
+      },
+      "test/phonopy_disp_TiO2.yaml": {
+        "size": 19499
+      },
+      "test/phonopy_load/test_phonopy_load.py": {
+        "size": 1011
+      },
+      "test/phonopy_params_Si.yaml": {
+        "size": 5187
+      },
+      "test/phonopy_params_Zr3N4.yaml": {
+        "size": 22776
+      },
+      "test/polymlp_KCL-120.yaml": {
+        "size": 195626
+      },
+      "test/qha/test_QHA.py": {
+        "size": 8235
+      },
+      "test/qha/test_QHA_efe.py": {
+        "size": 8662
+      },
+      "test/qha/test_electron.py": {
+        "size": 10737
+      },
+      "test/spectrum/test_dynamic_structure_factor.py": {
+        "size": 9502
+      },
+      "test/spectrum/test_velocity.py": {
+        "size": 770
+      },
+      "test/sscha/test_core.py": {
+        "size": 805
+      },
+      "test/structure/Si-conv.yaml": {
+        "size": 1155
+      },
+      "test/structure/SiO2-123.yaml": {
+        "size": 4346
+      },
+      "test/structure/test_atoms.py": {
+        "size": 11715
+      },
+      "test/structure/test_brillouin_zone.py": {
+        "size": 1985
+      },
+      "test/structure/test_cells.py": {
+        "size": 15821
+      },
+      "test/structure/test_grid_points.py": {
+        "size": 16981
+      },
+      "test/structure/test_symmetry.py": {
+        "size": 11280
+      },
+      "test/structure/test_tetrahedron_method.py": {
+        "size": 11232
+      },
+      "test/structure/tio2_qpoints.yaml": {
+        "size": 2469
+      },
+      "test/test_exception.py": {
+        "size": 395
+      },
+      "test/test_file_IO.py": {
+        "size": 2315
+      },
+      "test/unfolding/plot_band.py": {
+        "size": 379
+      },
+      "test/unfolding/test_unfolding.py": {
+        "size": 4763
+      }
+    },
+    "processed_by": "zip_fallback",
+    "success": true
+  },
+  "structure": {
+    "packages": [
+      "source.phonopy"
+    ]
+  },
+  "dependencies": {
+    "has_environment_yml": false,
+    "has_requirements_txt": true,
+    "pyproject": true,
+    "setup_cfg": false,
+    "setup_py": false
+  },
+  "entry_points": {
+    "imports": [],
+    "cli": [],
+    "modules": []
+  },
+  "llm_analysis": {
+    "core_modules": [
+      {
+        "package": "phonopy",
+        "module": "api_phonopy",
+        "functions": [
+          "Phonopy",
+          "PhonopyAtoms"
+        ],
+        "classes": [
+          "Phonopy",
+          "PhonopyAtoms"
+        ],
+        "description": "Core module for phonon calculations and handling atomic structures."
+      },
+      {
+        "package": "phonopy",
+        "module": "api_gruneisen",
+        "functions": [
+          "Gruneisen"
+        ],
+        "classes": [
+          "Gruneisen"
+        ],
+        "description": "Module for Gruneisen parameter calculations."
+      },
+      {
+        "package": "phonopy",
+        "module": "api_qha",
+        "functions": [
+          "QHA"
+        ],
+        "classes": [
+          "QHA"
+        ],
+        "description": "Module for quasi-harmonic approximation calculations."
+      }
+    ],
+    "cli_commands": [
+      {
+        "name": "phonopy",
+        "module": "phonopy.scripts.phonopy",
+        "description": "Main command-line interface for phonopy."
+      },
+      {
+        "name": "phonopy-bandplot",
+        "module": "phonopy.scripts.phonopy_bandplot",
+        "description": "Command-line tool for plotting phonon band structures."
+      },
+      {
+        "name": "phonopy-gruneisen",
+        "module": "phonopy.scripts.phonopy_gruneisen",
+        "description": "Command-line tool for Gruneisen parameter calculations."
+      }
+    ],
+    "import_strategy": {
+      "primary": "import",
+      "fallback": "cli",
+      "confidence": 0.9
+    },
+    "dependencies": {
+      "required": [
+        "numpy",
+        "scipy",
+        "matplotlib"
+      ],
+      "optional": [
+        "ase",
+        "spglib"
+      ]
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.8,
+      "intrusiveness_risk": "medium",
+      "complexity": "medium"
+    }
+  },
+  "deepwiki_analysis": {
+    "repo_url": "https://github.com/phonopy/phonopy",
+    "repo_name": "phonopy",
+    "content": "phonopy/phonopy\nGetting Started\nInstallation\nQuick Start Tutorial\nCore Concepts\nCrystal Structures and Cells\nSymmetry Operations\nForce Constants\nDynamical Matrices\nAPI Reference\nPhonopy Class\nCommand-Line Interface\nSettings and Configuration\nFile I/O and Data Formats\nPhonon Calculations\nBand Structure\nMesh Sampling and Reciprocal Space\nDensity of States\nThermal Properties\nGroup Velocities and Derivatives\nCalculator Interfaces\nInterface Architecture\nVASP Interface\nQuantum ESPRESSO Interface\nAbinit and Wien2k Interfaces\nOther Calculator Interfaces\nForce Constant Methods\nTraditional Finite Difference\nSymfc Interface\nALM Interface\nMethod Comparison and Selection\nAdvanced Topics\nNon-Analytic Term Correction\nIrreducible Representations\nDerivative Dynamical Matrix\nGrüneisen Parameters\nQuasi-Harmonic Approximation\nRandom Displacements and Modulations\nMachine Learning Potentials\nPyPolymlp Integration\nMLP Training and Evaluation\nC Extensions and Performance\nDevelopment Guide\nBuild System and Compilation\nCode Quality Tools\nTesting Framework\nContributing Guidelines\nCMakeLists.txt\ndoc/changelog.md\ndoc/conf.py\ndoc/install.md\nget_nanoversion.sh\nphonopy/__init__.py\nphonopy/api_phonopy.py\nphonopy/cui/load.py\nphonopy/cui/load_helper.py\nphonopy/cui/phonopy_argparse.py\nphonopy/cui/phonopy_script.py\nphonopy/cui/settings.py\nphonopy/file_IO.py\nphonopy/interface/phonopy_yaml.py\nphonopy/version.py\npyproject.toml\nrequirements.txt\nPhonopy is a Python package for phonon calculations in the harmonic approximation. The software computes phonon frequencies, band structures, density of states, and thermodynamic properties by solving the lattice dynamics eigenvalue problem from interatomic force constants. Current version is 2.46.1.\nPurpose and Scope\nPhonopy processes crystal structures and atomic forces to calculate phonon properties through a four-stage workflow:\nDisplacement Generation: Create supercells with atomic displacements (systematic or random)\nForce Calculation: Compute forces using external DFT/force calculators (user performs this step)\nForce Constant Calculation: Derive force constants from displacement-force datasets using finite difference, symfc (default since v2.30.0), or ALM methods\nPhonon Property Calculation: Solve dynamical matrix eigenvalue problem to obtain frequencies and thermodynamic properties\nThe package provides two user interfaces:\nCommand-line:phonopyandphonopy-loadcommands\nphonopy-load\nPython API:Phonopyclass andload()function\nPhonopy supports 18+ calculator interfaces (VASP, Quantum ESPRESSO, ABINIT, Wien2k, CRYSTAL, etc.) and multiple file formats (traditional text files, YAML, HDF5).\nSources:phonopy/version.py37phonopy/api_phonopy.py109phonopy/cui/load.py55doc/changelog.md1-200\nHigh-Level Architecture\nPhonopy follows a layered architecture with thePhonopyclass (phonopy/api_phonopy.py109) as the central orchestrator. The system is organized into six major subsystems:\nPhonopy System Architecture\nFile_IOCalculator_InterfacesPhonon_AnalysisDynamical_Matrix_SystemForce_Constant_CalculationCrystal_Structure_SystemCore_OrchestrationUser_Interfacesphonopy commandphonopy_script.pyphonopy-load commandscripts/phonopy_load.pyPhonopy classapi_phonopy.py:109load functioncui/load.py:55Phonopy Coreapi_phonopy.py:109State ManagementMethod OrchestrationPhonopyAtomsstructure/atoms.py:50Supercellstructure/cells.py:94Primitivestructure/cells.py:450Symmetrystructure/symmetry.pyget_fc2fc_calculator.py:71FDFCSolverTraditional FDSymfcFCSolverSymfc defaultALMFCSolverALM higher-orderDynamicalMatrixdynamical_matrix.py:48DynamicalMatrixNACdynamical_matrix.py:248Polar materialsBandStructureband_structure.py:49Mesh/IterMeshmesh.py:49ThermalPropertiesthermal_properties.py:39TotalDos/ProjectedDosdos.py:40GroupVelocitygroup_velocity.py:40Calculator Dispatchercalculator.pyVASPvasp.pyQuantum ESPRESSOqe.py15+ Other Calculatorsabinit, wien2k, etc.phonopy.yamlphonopy_yaml.py:374FORCE_SETS, BORNfile_IO.pyHDF5 Formatforce_constants.hdf5\nCalculator_Interfaces\nPhonon_Analysis\nDynamical_Matrix_System\nForce_Constant_Calculation\nCrystal_Structure_System\nCore_Orchestration\nUser_Interfaces\nphonopy commandphonopy_script.py\nphonopy-load commandscripts/phonopy_load.py\nPhonopy classapi_phonopy.py:109\nload functioncui/load.py:55\nPhonopy Coreapi_phonopy.py:109State ManagementMethod Orchestration\nPhonopyAtomsstructure/atoms.py:50\nSupercellstructure/cells.py:94\nPrimitivestructure/cells.py:450\nSymmetrystructure/symmetry.py\nget_fc2fc_calculator.py:71\nFDFCSolverTraditional FD\nSymfcFCSolverSymfc default\nALMFCSolverALM higher-order\nDynamicalMatrixdynamical_matrix.py:48\nDynamicalMatrixNACdynamical_matrix.py:248Polar materials\nBandStructureband_structure.py:49\nMesh/IterMeshmesh.py:49\nThermalPropertiesthermal_properties.py:39\nTotalDos/ProjectedDosdos.py:40\nGroupVelocitygroup_velocity.py:40\nCalculator Dispatchercalculator.py\nVASPvasp.py\nQuantum ESPRESSOqe.py\n15+ Other Calculatorsabinit, wien2k, etc.\nphonopy.yamlphonopy_yaml.py:374\nFORCE_SETS, BORNfile_IO.py\nHDF5 Formatforce_constants.hdf5\nSubsystem Descriptions\nPhonopyAtoms\nSymfcFCSolver\nALMFCSolver\nDynamicalMatrix\nDynamicalMatrixNAC\nBandStructure\nThermalProperties\nGroupVelocity\nPhonopyYaml\nSources:phonopy/api_phonopy.py109phonopy/structure/cells.py94phonopy/structure/cells.py450phonopy/interface/fc_calculator.py71phonopy/harmonic/dynamical_matrix.py48phonopy/phonon/band_structure.py49phonopy/interface/calculator.py\nComputational Pipeline\nThe typical phonon calculation workflow proceeds through five phases:\nPhonopy Computational Pipeline\nPhase5_Phonon_CalculationsPhase4_Force_ProcessingPhase3_External_CalculationPhase2_Displacement_GenerationPhase1_Structure_ProcessingInput StructurePOSCAR/phonopy.yamlParse Structureread_crystal_structurePhonopyAtomsunitcellBuild Supercell_build_supercellBuild Primitive_build_primitive_cellAnalyze SymmetrySymmetry classSupercell InstancePrimitive Instancegenerate_displacementsapi_phonopy.py:883Systematic FDget_least_displacementsRandom Displacementsget_random_displacementsWrite Displaced SupercellsPOSCAR-001, etc.User Runs DFT/Force CalculatorVASP, QE, etc.Parse ForcesCalculator InterfaceCreate Datasetdisplacements + forcesCalculate FCproduce_force_constantsFCSolversymfc defaultSymmetrize FCsymmetrize_force_constantsSetup Dynamical Matrix_set_dynamical_matrixApply NAC if neededDynamicalMatrixNACBand Structurerun_band_structureMesh Samplingrun_meshThermal Propertiesrun_thermal_propertiesDOS Calculationrun_total_dos\nPhase5_Phonon_Calculations\nPhase4_Force_Processing\nPhase3_External_Calculation\nPhase2_Displacement_Generation\nPhase1_Structure_Processing\nInput StructurePOSCAR/phonopy.yaml\nParse Structureread_crystal_structure\nPhonopyAtomsunitcell\nBuild Supercell_build_supercell\nBuild Primitive_build_primitive_cell\nAnalyze SymmetrySymmetry class\nSupercell Instance\nPrimitive Instance\ngenerate_displacementsapi_phonopy.py:883\nSystematic FDget_least_displacements\nRandom Displacementsget_random_displacements\nWrite Displaced SupercellsPOSCAR-001, etc.\nUser Runs DFT/Force CalculatorVASP, QE, etc.\nParse ForcesCalculator Interface\nCreate Datasetdisplacements + forces\nCalculate FCproduce_force_constants\nFCSolversymfc default\nSymmetrize FCsymmetrize_force_constants\nSetup Dynamical Matrix_set_dynamical_matrix\nApply NAC if neededDynamicalMatrixNAC\nBand Structurerun_band_structure\nMesh Samplingrun_mesh\nThermal Propertiesrun_thermal_properties\nDOS Calculationrun_total_dos\nKey Pipeline Stages:\nStructure Processing(Page 3.1): Parse input structure → build supercell/primitive → analyze symmetry\nDisplacement Generation(Page 4.1): Create systematic (FD) or random displacements usinggenerate_displacements()\ngenerate_displacements()\nExternal Calculation: User performs force calculations (external to Phonopy)\nForce Processing(Page 7): Parse forces → create dataset → calculate force constants using symfc/traditional/ALM\nPhonon Calculations(Page 5): Setup dynamical matrix → apply NAC → compute band structure, DOS, thermal properties\nSources:phonopy/api_phonopy.py883phonopy/api_phonopy.py1120phonopy/api_phonopy.py1355phonopy/api_phonopy.py1452phonopy/api_phonopy.py1721phonopy/api_phonopy.py2346phonopy/api_phonopy.py2374phonopy/interface/calculator.py104phonopy/interface/fc_calculator.py71\nCore Components\nPhonopy Class\nThePhonopyclass (phonopy/api_phonopy.py109) serves as the main API and central orchestrator. Detailed documentation is in Page 4.1.\nKey State Attributes:\nPhonopyAtoms\nforce_constants\ndynamical_matrix\nDynamicalMatrix\nKey Workflow Methods:\ngenerate_displacements()\nproduce_force_constants()\nrun_band_structure()\nrun_thermal_properties()\nSources:phonopy/api_phonopy.py109phonopy/api_phonopy.py883phonopy/api_phonopy.py1120phonopy/api_phonopy.py1355phonopy/api_phonopy.py1452phonopy/api_phonopy.py1721\nConfiguration and Settings\nConfiguration is managed through theSettingsclass (phonopy/cui/settings.py57) andConfParserclass (phonopy/cui/settings.py129). Settings control:\nCalculation mode (band structure, mesh, DOS, thermal properties)\nForce constants calculator selection (traditional, symfc, ALM)\nDisplacement generation parameters\nFile I/O options\nSymmetry handling\nSee Page 4.3 for detailed configuration documentation.\nSources:phonopy/cui/settings.py57phonopy/cui/settings.py129\nFile I/O System\nPhonopy supports three file format categories:\nTraditional text files:FORCE_SETS,FORCE_CONSTANTS,BORN(parsers inphonopy/file_IO.py)\nFORCE_CONSTANTS\nYAML format:phonopy.yaml,phonopy_disp.yaml(handled byPhonopyYamlclass atphonopy/interface/phonopy_yaml.py374)\nphonopy.yaml\nphonopy_disp.yaml\nPhonopyYaml\nHDF5 format:force_constants.hdf5,mesh.hdf5,band.hdf5(binary with compression support since v2.46.0)\nforce_constants.hdf5",
+    "model": "gpt-4o-2024-08-06",
+    "source": "selenium",
+    "success": true
+  },
+  "deepwiki_options": {
+    "enabled": true,
+    "model": "gpt-4o-2024-08-06"
+  },
+  "risk": {
+    "import_feasibility": 0.8,
+    "intrusiveness_risk": "medium",
+    "complexity": "medium"
+  }
+}

phonopy/mcp_output/diff_report.md

@@ -0,0 +1,63 @@
+# Phonopy Project Difference Report
+
+**Repository:** phonopy  
+**Project Type:** Python Library  
+**Main Features:** Basic Functionality  
+**Report Generated On:** 2026-01-31 12:45:56  
+**Intrusiveness:** None  
+**Workflow Status:** Success  
+**Test Status:** Failed  
+
+## Project Overview
+
+Phonopy is a Python library designed to provide basic functionalities for phonon calculations. It is widely used in computational materials science for analyzing vibrational properties of crystals. The project is open-source and continually evolving to incorporate new features and improvements.
+
+## Difference Analysis
+
+### New Files Added
+
+In this update, 8 new files have been introduced to the repository. These files are likely to contain new features, enhancements, or additional documentation. However, no existing files were modified, indicating that the new additions are non-intrusive and do not alter the current functionality of the library.
+
+### Modified Files
+
+There were no modifications to existing files in this update. This suggests that the core functionality remains unchanged, and the focus was on expanding the library's capabilities or adding supplementary resources.
+
+## Technical Analysis
+
+### Workflow Status
+
+The workflow status is marked as "success," indicating that the integration and deployment processes were executed without any issues. This suggests that the new files were correctly integrated into the existing codebase.
+
+### Test Status
+
+The test status is marked as "failed," which is a critical issue that needs immediate attention. This failure indicates that the new additions may have introduced bugs or that the existing test suite is not comprehensive enough to cover the new functionalities.
+
+## Recommendations and Improvements
+
+1. **Investigate Test Failures:** Conduct a thorough investigation to identify the cause of the test failures. This may involve reviewing the new files for potential bugs or updating the test suite to accommodate new features.
+
+2. **Enhance Test Coverage:** Ensure that the test suite is comprehensive and covers all new functionalities introduced by the recent update. This will help in maintaining the reliability and stability of the library.
+
+3. **Documentation Update:** If the new files include new features or enhancements, update the documentation to reflect these changes. This will assist users in understanding and utilizing the new functionalities effectively.
+
+4. **Code Review:** Conduct a code review of the new files to ensure they adhere to the project's coding standards and best practices. This will help in maintaining code quality and consistency.
+
+## Deployment Information
+
+The deployment of the new files was successful, as indicated by the workflow status. However, due to the test failures, it is advisable to hold off on any production deployment until the issues are resolved.
+
+## Future Planning
+
+1. **Bug Fixes:** Prioritize resolving the test failures and any identified bugs in the new files.
+
+2. **Feature Expansion:** Consider planning for future updates that expand on the newly introduced functionalities, ensuring they align with the project's goals and user needs.
+
+3. **Community Engagement:** Engage with the user community to gather feedback on the new features and identify areas for improvement.
+
+4. **Regular Updates:** Establish a regular update schedule to ensure the library remains up-to-date with the latest advancements in phonon calculations and computational materials science.
+
+## Conclusion
+
+The recent update to the Phonopy project introduced new files that expand the library's capabilities. However, the test failures highlight the need for immediate attention to ensure the stability and reliability of the library. By addressing these issues and following the recommendations outlined in this report, the project can continue to provide valuable tools for the scientific community.
+
+---

phonopy/mcp_output/mcp_plugin/adapter.py

@@ -0,0 +1,132 @@
+import os
+import sys
+
+# Path settings
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+# Import statements
+from phonopy.api_phonopy import Phonopy
+from phonopy.cui.load import load
+from phonopy.cui.settings import Settings
+from phonopy.interface.calculator import Calculator
+from phonopy.interface.phonopy_yaml import PhonopyYaml
+
+class Adapter:
+    """
+    Adapter class for MCP plugin to interact with the Phonopy library.
+    This class provides methods to utilize Phonopy's functionalities.
+    """
+
+    def __init__(self):
+        self.mode = "import"
+
+    # -------------------------------------------------------------------------
+    # Instance Methods
+    # -------------------------------------------------------------------------
+
+    def create_phonopy_instance(self, unitcell, supercell_matrix, primitive_matrix=None):
+        """
+        Create an instance of the Phonopy class.
+
+        Parameters:
+        - unitcell: Unit cell structure
+        - supercell_matrix: Supercell transformation matrix
+        - primitive_matrix: Primitive cell transformation matrix (optional)
+
+        Returns:
+        - dict: {'status': 'success', 'phonopy_instance': Phonopy object} or {'status': 'error', 'message': str}
+        """
+        try:
+            phonopy_instance = Phonopy(unitcell, supercell_matrix, primitive_matrix)
+            return {'status': 'success', 'phonopy_instance': phonopy_instance}
+        except Exception as e:
+            return {'status': 'error', 'message': f"Failed to create Phonopy instance: {str(e)}"}
+
+    def create_settings_instance(self, config):
+        """
+        Create an instance of the Settings class.
+
+        Parameters:
+        - config: Configuration dictionary
+
+        Returns:
+        - dict: {'status': 'success', 'settings_instance': Settings object} or {'status': 'error', 'message': str}
+        """
+        try:
+            settings_instance = Settings(config)
+            return {'status': 'success', 'settings_instance': settings_instance}
+        except Exception as e:
+            return {'status': 'error', 'message': f"Failed to create Settings instance: {str(e)}"}
+
+    def create_calculator_instance(self, calculator_type, **kwargs):
+        """
+        Create an instance of the Calculator class.
+
+        Parameters:
+        - calculator_type: Type of calculator (e.g., 'vasp', 'qe')
+        - kwargs: Additional parameters for the calculator
+
+        Returns:
+        - dict: {'status': 'success', 'calculator_instance': Calculator object} or {'status': 'error', 'message': str}
+        """
+        try:
+            calculator_instance = Calculator(calculator_type, **kwargs)
+            return {'status': 'success', 'calculator_instance': calculator_instance}
+        except Exception as e:
+            return {'status': 'error', 'message': f"Failed to create Calculator instance: {str(e)}"}
+
+    def create_phonopy_yaml_instance(self, yaml_file):
+        """
+        Create an instance of the PhonopyYaml class.
+
+        Parameters:
+        - yaml_file: Path to the YAML file
+
+        Returns:
+        - dict: {'status': 'success', 'phonopy_yaml_instance': PhonopyYaml object} or {'status': 'error', 'message': str}
+        """
+        try:
+            phonopy_yaml_instance = PhonopyYaml(yaml_file)
+            return {'status': 'success', 'phonopy_yaml_instance': phonopy_yaml_instance}
+        except Exception as e:
+            return {'status': 'error', 'message': f"Failed to create PhonopyYaml instance: {str(e)}"}
+
+    # -------------------------------------------------------------------------
+    # Call Methods
+    # -------------------------------------------------------------------------
+
+    def call_load_function(self, filename):
+        """
+        Call the load function from the Phonopy library.
+
+        Parameters:
+        - filename: Path to the file to be loaded
+
+        Returns:
+        - dict: {'status': 'success', 'data': loaded data} or {'status': 'error', 'message': str}
+        """
+        try:
+            data = load(filename)
+            return {'status': 'success', 'data': data}
+        except Exception as e:
+            return {'status': 'error', 'message': f"Failed to load data: {str(e)}"}
+
+    # -------------------------------------------------------------------------
+    # Error Handling and Fallback
+    # -------------------------------------------------------------------------
+
+    def handle_import_failure(self):
+        """
+        Handle import failure cases and provide a graceful fallback.
+
+        Returns:
+        - dict: {'status': 'error', 'message': str}
+        """
+        return {'status': 'error', 'message': "Import failed. Please ensure all dependencies are installed and accessible."}
+
+# Example usage
+if __name__ == "__main__":
+    adapter = Adapter()
+    result = adapter.create_phonopy_instance(unitcell="unitcell", supercell_matrix="supercell_matrix")
+    print(result)

phonopy/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry point"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

phonopy/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,97 @@
+import os
+import sys
+
+# Add the local source directory to sys.path
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+if source_path not in sys.path:
+    sys.path.insert(0, source_path)
+
+from fastmcp import FastMCP
+from phonopy.api_phonopy import Phonopy
+from phonopy.cui.load import load
+from phonopy.cui.settings import Settings
+
+# Create the FastMCP service application
+mcp = FastMCP("phonopy_service")
+
+@mcp.tool(name="generate_displacements", description="Generate atomic displacements for phonon calculations.")
+def generate_displacements(structure_file: str) -> dict:
+    """
+    Generates atomic displacements for phonon calculations.
+
+    Parameters:
+    - structure_file (str): Path to the input structure file.
+
+    Returns:
+    - dict: A dictionary containing success, result, or error fields.
+    """
+    try:
+        phonopy_instance = load(structure_file)
+        displacements = phonopy_instance.generate_displacements()
+        return {"success": True, "result": displacements}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+@mcp.tool(name="calculate_force_constants", description="Calculate force constants from displacement-force datasets.")
+def calculate_force_constants(displacement_file: str, force_file: str) -> dict:
+    """
+    Calculates force constants from displacement-force datasets.
+
+    Parameters:
+    - displacement_file (str): Path to the displacement data file.
+    - force_file (str): Path to the force data file.
+
+    Returns:
+    - dict: A dictionary containing success, result, or error fields.
+    """
+    try:
+        phonopy_instance = load(displacement_file)
+        phonopy_instance.produce_force_constants(force_file)
+        return {"success": True, "result": "Force constants calculated successfully."}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+@mcp.tool(name="run_band_structure", description="Run phonon band structure calculations.")
+def run_band_structure(structure_file: str) -> dict:
+    """
+    Runs phonon band structure calculations.
+
+    Parameters:
+    - structure_file (str): Path to the input structure file.
+
+    Returns:
+    - dict: A dictionary containing success, result, or error fields.
+    """
+    try:
+        phonopy_instance = load(structure_file)
+        band_structure = phonopy_instance.run_band_structure()
+        return {"success": True, "result": band_structure}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+@mcp.tool(name="run_thermal_properties", description="Calculate thermal properties of the material.")
+def run_thermal_properties(structure_file: str) -> dict:
+    """
+    Calculates thermal properties of the material.
+
+    Parameters:
+    - structure_file (str): Path to the input structure file.
+
+    Returns:
+    - dict: A dictionary containing success, result, or error fields.
+    """
+    try:
+        phonopy_instance = load(structure_file)
+        thermal_properties = phonopy_instance.run_thermal_properties()
+        return {"success": True, "result": thermal_properties}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def create_app() -> FastMCP:
+    """
+    Creates and returns the FastMCP application instance.
+
+    Returns:
+    - FastMCP: The FastMCP application instance.
+    """
+    return mcp

phonopy/mcp_output/requirements.txt

@@ -0,0 +1,11 @@
+fastmcp
+fastapi
+uvicorn[standard]
+pydantic>=2.0.0
+numpy >= 1.17.0
+PyYAML >= 5.3
+matplotlib >= 2.2.2
+h5py >= 3.0
+spglib >= 2.5
+symfc>=1.5
+scipy

phonopy/mcp_output/start_mcp.py

@@ -0,0 +1,30 @@
+
+"""
+MCP Service Startup Entry
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+from mcp_service import create_app
+
+def main():
+    """Start FastMCP service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Choose transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

phonopy/mcp_output/workflow_summary.json

@@ -0,0 +1,194 @@
+{
+  "repository": {
+    "name": "phonopy",
+    "url": "https://github.com/phonopy/phonopy",
+    "local_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/phonopy",
+    "description": "Python library",
+    "features": "Basic functionality",
+    "tech_stack": "Python",
+    "stars": 0,
+    "forks": 0,
+    "language": "Python",
+    "last_updated": "",
+    "complexity": "medium",
+    "intrusiveness_risk": "medium"
+  },
+  "execution": {
+    "start_time": 1769834614.195348,
+    "end_time": 1769834692.488752,
+    "duration": 78.29340410232544,
+    "status": "success",
+    "workflow_status": "success",
+    "nodes_executed": [
+      "download",
+      "analysis",
+      "env",
+      "generate",
+      "run",
+      "review",
+      "finalize"
+    ],
+    "total_files_processed": 1,
+    "environment_type": "unknown",
+    "llm_calls": 0,
+    "deepwiki_calls": 0
+  },
+  "tests": {
+    "original_project": {
+      "passed": false,
+      "details": {},
+      "test_coverage": "100%",
+      "execution_time": 0,
+      "test_files": []
+    },
+    "mcp_plugin": {
+      "passed": true,
+      "details": {},
+      "service_health": "healthy",
+      "startup_time": 0,
+      "transport_mode": "stdio",
+      "fastmcp_version": "unknown",
+      "mcp_version": "unknown"
+    }
+  },
+  "analysis": {
+    "structure": {
+      "packages": [
+        "source.phonopy"
+      ]
+    },
+    "dependencies": {
+      "has_environment_yml": false,
+      "has_requirements_txt": true,
+      "pyproject": true,
+      "setup_cfg": false,
+      "setup_py": false
+    },
+    "entry_points": {
+      "imports": [],
+      "cli": [],
+      "modules": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.8,
+      "intrusiveness_risk": "medium",
+      "complexity": "medium"
+    },
+    "deepwiki_analysis": {
+      "repo_url": "https://github.com/phonopy/phonopy",
+      "repo_name": "phonopy",
+      "content": "phonopy/phonopy\nGetting Started\nInstallation\nQuick Start Tutorial\nCore Concepts\nCrystal Structures and Cells\nSymmetry Operations\nForce Constants\nDynamical Matrices\nAPI Reference\nPhonopy Class\nCommand-Line Interface\nSettings and Configuration\nFile I/O and Data Formats\nPhonon Calculations\nBand Structure\nMesh Sampling and Reciprocal Space\nDensity of States\nThermal Properties\nGroup Velocities and Derivatives\nCalculator Interfaces\nInterface Architecture\nVASP Interface\nQuantum ESPRESSO Interface\nAbinit and Wien2k Interfaces\nOther Calculator Interfaces\nForce Constant Methods\nTraditional Finite Difference\nSymfc Interface\nALM Interface\nMethod Comparison and Selection\nAdvanced Topics\nNon-Analytic Term Correction\nIrreducible Representations\nDerivative Dynamical Matrix\nGrüneisen Parameters\nQuasi-Harmonic Approximation\nRandom Displacements and Modulations\nMachine Learning Potentials\nPyPolymlp Integration\nMLP Training and Evaluation\nC Extensions and Performance\nDevelopment Guide\nBuild System and Compilation\nCode Quality Tools\nTesting Framework\nContributing Guidelines\nCMakeLists.txt\ndoc/changelog.md\ndoc/conf.py\ndoc/install.md\nget_nanoversion.sh\nphonopy/__init__.py\nphonopy/api_phonopy.py\nphonopy/cui/load.py\nphonopy/cui/load_helper.py\nphonopy/cui/phonopy_argparse.py\nphonopy/cui/phonopy_script.py\nphonopy/cui/settings.py\nphonopy/file_IO.py\nphonopy/interface/phonopy_yaml.py\nphonopy/version.py\npyproject.toml\nrequirements.txt\nPhonopy is a Python package for phonon calculations in the harmonic approximation. The software computes phonon frequencies, band structures, density of states, and thermodynamic properties by solving the lattice dynamics eigenvalue problem from interatomic force constants. Current version is 2.46.1.\nPurpose and Scope\nPhonopy processes crystal structures and atomic forces to calculate phonon properties through a four-stage workflow:\nDisplacement Generation: Create supercells with atomic displacements (systematic or random)\nForce Calculation: Compute forces using external DFT/force calculators (user performs this step)\nForce Constant Calculation: Derive force constants from displacement-force datasets using finite difference, symfc (default since v2.30.0), or ALM methods\nPhonon Property Calculation: Solve dynamical matrix eigenvalue problem to obtain frequencies and thermodynamic properties\nThe package provides two user interfaces:\nCommand-line:phonopyandphonopy-loadcommands\nphonopy-load\nPython API:Phonopyclass andload()function\nPhonopy supports 18+ calculator interfaces (VASP, Quantum ESPRESSO, ABINIT, Wien2k, CRYSTAL, etc.) and multiple file formats (traditional text files, YAML, HDF5).\nSources:phonopy/version.py37phonopy/api_phonopy.py109phonopy/cui/load.py55doc/changelog.md1-200\nHigh-Level Architecture\nPhonopy follows a layered architecture with thePhonopyclass (phonopy/api_phonopy.py109) as the central orchestrator. The system is organized into six major subsystems:\nPhonopy System Architecture\nFile_IOCalculator_InterfacesPhonon_AnalysisDynamical_Matrix_SystemForce_Constant_CalculationCrystal_Structure_SystemCore_OrchestrationUser_Interfacesphonopy commandphonopy_script.pyphonopy-load commandscripts/phonopy_load.pyPhonopy classapi_phonopy.py:109load functioncui/load.py:55Phonopy Coreapi_phonopy.py:109State ManagementMethod OrchestrationPhonopyAtomsstructure/atoms.py:50Supercellstructure/cells.py:94Primitivestructure/cells.py:450Symmetrystructure/symmetry.pyget_fc2fc_calculator.py:71FDFCSolverTraditional FDSymfcFCSolverSymfc defaultALMFCSolverALM higher-orderDynamicalMatrixdynamical_matrix.py:48DynamicalMatrixNACdynamical_matrix.py:248Polar materialsBandStructureband_structure.py:49Mesh/IterMeshmesh.py:49ThermalPropertiesthermal_properties.py:39TotalDos/ProjectedDosdos.py:40GroupVelocitygroup_velocity.py:40Calculator Dispatchercalculator.pyVASPvasp.pyQuantum ESPRESSOqe.py15+ Other Calculatorsabinit, wien2k, etc.phonopy.yamlphonopy_yaml.py:374FORCE_SETS, BORNfile_IO.pyHDF5 Formatforce_constants.hdf5\nCalculator_Interfaces\nPhonon_Analysis\nDynamical_Matrix_System\nForce_Constant_Calculation\nCrystal_Structure_System\nCore_Orchestration\nUser_Interfaces\nphonopy commandphonopy_script.py\nphonopy-load commandscripts/phonopy_load.py\nPhonopy classapi_phonopy.py:109\nload functioncui/load.py:55\nPhonopy Coreapi_phonopy.py:109State ManagementMethod Orchestration\nPhonopyAtomsstructure/atoms.py:50\nSupercellstructure/cells.py:94\nPrimitivestructure/cells.py:450\nSymmetrystructure/symmetry.py\nget_fc2fc_calculator.py:71\nFDFCSolverTraditional FD\nSymfcFCSolverSymfc default\nALMFCSolverALM higher-order\nDynamicalMatrixdynamical_matrix.py:48\nDynamicalMatrixNACdynamical_matrix.py:248Polar materials\nBandStructureband_structure.py:49\nMesh/IterMeshmesh.py:49\nThermalPropertiesthermal_properties.py:39\nTotalDos/ProjectedDosdos.py:40\nGroupVelocitygroup_velocity.py:40\nCalculator Dispatchercalculator.py\nVASPvasp.py\nQuantum ESPRESSOqe.py\n15+ Other Calculatorsabinit, wien2k, etc.\nphonopy.yamlphonopy_yaml.py:374\nFORCE_SETS, BORNfile_IO.py\nHDF5 Formatforce_constants.hdf5\nSubsystem Descriptions\nPhonopyAtoms\nSymfcFCSolver\nALMFCSolver\nDynamicalMatrix\nDynamicalMatrixNAC\nBandStructure\nThermalProperties\nGroupVelocity\nPhonopyYaml\nSources:phonopy/api_phonopy.py109phonopy/structure/cells.py94phonopy/structure/cells.py450phonopy/interface/fc_calculator.py71phonopy/harmonic/dynamical_matrix.py48phonopy/phonon/band_structure.py49phonopy/interface/calculator.py\nComputational Pipeline\nThe typical phonon calculation workflow proceeds through five phases:\nPhonopy Computational Pipeline\nPhase5_Phonon_CalculationsPhase4_Force_ProcessingPhase3_External_CalculationPhase2_Displacement_GenerationPhase1_Structure_ProcessingInput StructurePOSCAR/phonopy.yamlParse Structureread_crystal_structurePhonopyAtomsunitcellBuild Supercell_build_supercellBuild Primitive_build_primitive_cellAnalyze SymmetrySymmetry classSupercell InstancePrimitive Instancegenerate_displacementsapi_phonopy.py:883Systematic FDget_least_displacementsRandom Displacementsget_random_displacementsWrite Displaced SupercellsPOSCAR-001, etc.User Runs DFT/Force CalculatorVASP, QE, etc.Parse ForcesCalculator InterfaceCreate Datasetdisplacements + forcesCalculate FCproduce_force_constantsFCSolversymfc defaultSymmetrize FCsymmetrize_force_constantsSetup Dynamical Matrix_set_dynamical_matrixApply NAC if neededDynamicalMatrixNACBand Structurerun_band_structureMesh Samplingrun_meshThermal Propertiesrun_thermal_propertiesDOS Calculationrun_total_dos\nPhase5_Phonon_Calculations\nPhase4_Force_Processing\nPhase3_External_Calculation\nPhase2_Displacement_Generation\nPhase1_Structure_Processing\nInput StructurePOSCAR/phonopy.yaml\nParse Structureread_crystal_structure\nPhonopyAtomsunitcell\nBuild Supercell_build_supercell\nBuild Primitive_build_primitive_cell\nAnalyze SymmetrySymmetry class\nSupercell Instance\nPrimitive Instance\ngenerate_displacementsapi_phonopy.py:883\nSystematic FDget_least_displacements\nRandom Displacementsget_random_displacements\nWrite Displaced SupercellsPOSCAR-001, etc.\nUser Runs DFT/Force CalculatorVASP, QE, etc.\nParse ForcesCalculator Interface\nCreate Datasetdisplacements + forces\nCalculate FCproduce_force_constants\nFCSolversymfc default\nSymmetrize FCsymmetrize_force_constants\nSetup Dynamical Matrix_set_dynamical_matrix\nApply NAC if neededDynamicalMatrixNAC\nBand Structurerun_band_structure\nMesh Samplingrun_mesh\nThermal Propertiesrun_thermal_properties\nDOS Calculationrun_total_dos\nKey Pipeline Stages:\nStructure Processing(Page 3.1): Parse input structure → build supercell/primitive → analyze symmetry\nDisplacement Generation(Page 4.1): Create systematic (FD) or random displacements usinggenerate_displacements()\ngenerate_displacements()\nExternal Calculation: User performs force calculations (external to Phonopy)\nForce Processing(Page 7): Parse forces → create dataset → calculate force constants using symfc/traditional/ALM\nPhonon Calculations(Page 5): Setup dynamical matrix → apply NAC → compute band structure, DOS, thermal properties\nSources:phonopy/api_phonopy.py883phonopy/api_phonopy.py1120phonopy/api_phonopy.py1355phonopy/api_phonopy.py1452phonopy/api_phonopy.py1721phonopy/api_phonopy.py2346phonopy/api_phonopy.py2374phonopy/interface/calculator.py104phonopy/interface/fc_calculator.py71\nCore Components\nPhonopy Class\nThePhonopyclass (phonopy/api_phonopy.py109) serves as the main API and central orchestrator. Detailed documentation is in Page 4.1.\nKey State Attributes:\nPhonopyAtoms\nforce_constants\ndynamical_matrix\nDynamicalMatrix\nKey Workflow Methods:\ngenerate_displacements()\nproduce_force_constants()\nrun_band_structure()\nrun_thermal_properties()\nSources:phonopy/api_phonopy.py109phonopy/api_phonopy.py883phonopy/api_phonopy.py1120phonopy/api_phonopy.py1355phonopy/api_phonopy.py1452phonopy/api_phonopy.py1721\nConfiguration and Settings\nConfiguration is managed through theSettingsclass (phonopy/cui/settings.py57) andConfParserclass (phonopy/cui/settings.py129). Settings control:\nCalculation mode (band structure, mesh, DOS, thermal properties)\nForce constants calculator selection (traditional, symfc, ALM)\nDisplacement generation parameters\nFile I/O options\nSymmetry handling\nSee Page 4.3 for detailed configuration documentation.\nSources:phonopy/cui/settings.py57phonopy/cui/settings.py129\nFile I/O System\nPhonopy supports three file format categories:\nTraditional text files:FORCE_SETS,FORCE_CONSTANTS,BORN(parsers inphonopy/file_IO.py)\nFORCE_CONSTANTS\nYAML format:phonopy.yaml,phonopy_disp.yaml(handled byPhonopyYamlclass atphonopy/interface/phonopy_yaml.py374)\nphonopy.yaml\nphonopy_disp.yaml\nPhonopyYaml\nHDF5 format:force_constants.hdf5,mesh.hdf5,band.hdf5(binary with compression support since v2.46.0)\nforce_constants.hdf5",
+      "model": "gpt-4o-2024-08-06",
+      "source": "selenium",
+      "success": true
+    },
+    "code_complexity": {
+      "cyclomatic_complexity": "medium",
+      "cognitive_complexity": "medium",
+      "maintainability_index": 75
+    },
+    "security_analysis": {
+      "vulnerabilities_found": 0,
+      "security_score": 85,
+      "recommendations": []
+    }
+  },
+  "plugin_generation": {
+    "files_created": [
+      "mcp_output/start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py",
+      "mcp_output/mcp_plugin/main.py",
+      "mcp_output/requirements.txt",
+      "mcp_output/README_MCP.md"
+    ],
+    "main_entry": "start_mcp.py",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ],
+    "readme_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/phonopy/mcp_output/README_MCP.md",
+    "adapter_mode": "import",
+    "total_lines_of_code": 0,
+    "generated_files_size": 0,
+    "tool_endpoints": 0,
+    "supported_features": [
+      "Basic functionality"
+    ],
+    "generated_tools": [
+      "Basic tools",
+      "Health check tools",
+      "Version info tools"
+    ]
+  },
+  "code_review": {},
+  "errors": [],
+  "warnings": [],
+  "recommendations": [
+    "Improve test coverage by adding more unit tests for critical modules",
+    "optimize large file handling to improve performance",
+    "enhance documentation for complex modules to aid understanding",
+    "implement continuous integration to automate testing and deployment",
+    "refactor code to reduce complexity and improve maintainability",
+    "ensure all dependencies are up-to-date to avoid security vulnerabilities",
+    "improve error handling to provide more informative messages",
+    "consider adding more examples and tutorials to help new users",
+    "streamline the build process to reduce setup time",
+    "conduct regular code reviews to maintain code quality."
+  ],
+  "performance_metrics": {
+    "memory_usage_mb": 0,
+    "cpu_usage_percent": 0,
+    "response_time_ms": 0,
+    "throughput_requests_per_second": 0
+  },
+  "deployment_info": {
+    "supported_platforms": [
+      "Linux",
+      "Windows",
+      "macOS"
+    ],
+    "python_versions": [
+      "3.8",
+      "3.9",
+      "3.10",
+      "3.11",
+      "3.12"
+    ],
+    "deployment_methods": [
+      "Docker",
+      "pip",
+      "conda"
+    ],
+    "monitoring_support": true,
+    "logging_configuration": "structured"
+  },
+  "execution_analysis": {
+    "success_factors": [
+      "Comprehensive workflow execution with all nodes completed successfully",
+      "Efficient processing of the repository with medium complexity"
+    ],
+    "failure_reasons": [],
+    "overall_assessment": "excellent",
+    "node_performance": {
+      "download_time": "Efficient download and setup of the repository",
+      "analysis_time": "Thorough analysis completed within expected duration",
+      "generation_time": "Code generation executed smoothly without delays",
+      "test_time": "Testing phase completed successfully with healthy service status"
+    },
+    "resource_usage": {
+      "memory_efficiency": "Memory usage was not explicitly measured, but no issues reported",
+      "cpu_efficiency": "CPU usage was not explicitly measured, but no issues reported",
+      "disk_usage": "Disk usage was efficient with minimal generated file size"
+    }
+  },
+  "technical_quality": {
+    "code_quality_score": 80,
+    "architecture_score": 85,
+    "performance_score": 75,
+    "maintainability_score": 75,
+    "security_score": 85,
+    "scalability_score": 80
+  }
+}

phonopy/source/.pre-commit-config.yaml

@@ -0,0 +1,26 @@
+# See https://pre-commit.com for more informatio
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+- repo: https://github.com/pre-commit/pre-commit-hooks
+  rev: v6.0.0
+  hooks:
+  - id: trailing-whitespace
+  - id: end-of-file-fixer
+  - id: check-yaml
+    exclude: ^conda/
+  - id: check-added-large-files
+  - id: mixed-line-ending
+    args: ['--fix=lf']
+
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  rev: v0.14.14
+  hooks:
+  - id: ruff
+    args: [ "--fix", "--show-fixes" ]
+  - id: ruff-format
+
+- repo: https://github.com/cheshirekow/cmake-format-precommit
+  rev: v0.6.13
+  hooks:
+  - id: cmake-format
+  - id: cmake-lint

phonopy/source/CMakeLists.txt

@@ -0,0 +1,119 @@
+cmake_minimum_required(VERSION 3.20)
+
+if(NOT SKBUILD_PROJECT_NAME)
+    set(SKBUILD_PROJECT_NAME phonopy)
+endif()
+
+if(PHONOPY_LIBS)
+    project(phonopy LANGUAGES C)
+    set(CMAKE_MACOSX_RPATH 1)
+    set(CMAKE_C_FLAGS_RELEASE "-Wall -O2")
+    set(CMAKE_C_FLAGS_DEBUG "-g -DTHMWARNING")
+    include(GNUInstallDirs)
+
+    # Version numbers
+    file(READ ${PROJECT_SOURCE_DIR}/phonopy/version.py VERSION_FILE)
+    string(REGEX MATCH "__version__.*([0-9]+)[.]([0-9]+)[.]([0-9]+)" phonopy_version
+                 ${VERSION_FILE})
+    set(PHONOPY_MAJOR_VERSION ${CMAKE_MATCH_1})
+    set(PHONOPY_MINOR_VERSION ${CMAKE_MATCH_2})
+    set(PHONOPY_MICRO_VERSION ${CMAKE_MATCH_3})
+    set(SERIAL
+        "${PHONOPY_MAJOR_VERSION}.${PHONOPY_MINOR_VERSION}.${PHONOPY_MICRO_VERSION}")
+    set(SOSERIAL "1")
+else()
+    project(${SKBUILD_PROJECT_NAME})
+    set(DEV_MODULE Development.Module)
+    find_package(
+        Python 3.9 REQUIRED
+        COMPONENTS Interpreter ${DEV_MODULE}
+        OPTIONAL_COMPONENTS Development.SABIModule)
+endif()
+
+cmake_policy(SET CMP0007 NEW)
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+    set(CMAKE_BUILD_TYPE
+        Release
+        CACHE STRING "Choose the type of build." FORCE)
+    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release"
+                                                 "MinSizeRel" "RelWithDebInfo")
+endif()
+
+option(PHONOPY_USE_OMP "Build with OpenMP support" ON)
+
+message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
+message(STATUS "CMAKE_SYSTEM_PREFIX_PATH: ${CMAKE_SYSTEM_PREFIX_PATH}")
+
+if(PHONOPY_USE_OMP)
+    find_package(OpenMP)
+
+    if(OpenMP_FOUND)
+        message(STATUS "OpenMP libs: ${OpenMP_C_LIBRARIES}")
+        message(STATUS "OpenMP flags: ${OpenMP_C_FLAGS}")
+    endif()
+else()
+    message(STATUS "OpenMP is not used.")
+    set(OpenMP_FOUND OFF) # cmake-lint: disable=C0103
+endif()
+
+set(SOURCES_PHONOPY
+    ${PROJECT_SOURCE_DIR}/c/phonopy.c ${PROJECT_SOURCE_DIR}/c/dynmat.c
+    ${PROJECT_SOURCE_DIR}/c/derivative_dynmat.c ${PROJECT_SOURCE_DIR}/c/rgrid.c
+    ${PROJECT_SOURCE_DIR}/c/tetrahedron_method.c)
+
+if(BUILD_SHARED_LIBS)
+    # Shared library
+    add_library(phonopy_libs SHARED ${SOURCES_PHONOPY})
+
+    if(OpenMP_FOUND)
+        target_link_libraries(phonopy_libs PRIVATE OpenMP::OpenMP_C)
+    endif()
+
+    target_compile_definitions(phonopy_libs PRIVATE THM_EPSILON=1e-10)
+else()
+    # Static link library
+    add_library(phonopy_libs STATIC ${SOURCES_PHONOPY})
+
+    if(OpenMP_FOUND)
+        target_link_libraries(phonopy_libs PRIVATE OpenMP::OpenMP_C)
+    endif()
+
+    target_compile_definitions(phonopy_libs PRIVATE THM_EPSILON=1e-10)
+endif()
+
+if(PHONOPY_LIBS)
+    install(FILES ${PROJECT_SOURCE_DIR}/c/phonopy.h
+            DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+    if(BUILD_SHARED_LIBS)
+        install(TARGETS phonopy_libs LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+        set_property(TARGET phonopy_libs PROPERTY VERSION ${SERIAL})
+        set_property(TARGET phonopy_libs PROPERTY SOVERSION ${SOSERIAL})
+    else()
+        install(TARGETS phonopy_libs ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+        set_property(TARGET phonopy_libs PROPERTY VERSION ${SERIAL})
+        set_property(TARGET phonopy_libs PROPERTY SOVERSION ${SOSERIAL})
+        set_property(TARGET phonopy_libs PROPERTY OUTPUT_NAME phonopy_libs)
+    endif()
+else()
+    set_target_properties(phonopy_libs PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+    execute_process(
+        COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        OUTPUT_VARIABLE NB_DIR)
+    list(APPEND CMAKE_PREFIX_PATH "${NB_DIR}")
+    find_package(nanobind CONFIG REQUIRED)
+    nanobind_add_module(_phonopy STABLE_ABI ${PROJECT_SOURCE_DIR}/c/phonopy.h
+                        ${PROJECT_SOURCE_DIR}/c/_phonopy.cpp)
+
+    if(OpenMP_FOUND)
+        target_link_libraries(_phonopy PRIVATE phonopy_libs OpenMP::OpenMP_C)
+    else()
+        target_link_libraries(_phonopy PRIVATE phonopy_libs)
+    endif()
+
+    target_compile_definitions(_phonopy PRIVATE THM_EPSILON=1e-10)
+    install(TARGETS _phonopy LIBRARY DESTINATION ${SKBUILD_PROJECT_NAME})
+endif()

phonopy/source/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2014-2024, Phonopy. All rights reserved.
+
+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 <COPYRIGHT
+HOLDER> 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.

phonopy/source/MANIFEST.in

@@ -0,0 +1,6 @@
+graft c
+graft example
+include __nanoversion__.txt
+include LICENSE
+recursive-include test *
+recursive-exclude test *.pyc

phonopy/source/README.md

@@ -0,0 +1,74 @@
+[![Version Badge](https://anaconda.org/conda-forge/phonopy/badges/version.svg)](https://anaconda.org/conda-forge/phonopy)
+[![Downloads Badge](https://anaconda.org/conda-forge/phonopy/badges/downloads.svg)](https://anaconda.org/conda-forge/phonopy)
+[![PyPI](https://img.shields.io/pypi/dm/phonopy.svg?maxAge=2592000)](https://pypi.python.org/pypi/phonopy)
+[![codecov](https://codecov.io/gh/phonopy/phonopy/branch/develop/graph/badge.svg)](https://codecov.io/gh/phonopy/phonopy)
+
+# Phonopy
+
+Phonon code mainly written in python. Phonopy user documentation is found at
+http://phonopy.github.io/phonopy/
+
+## Installation
+
+See https://phonopy.github.io/phonopy/install.html.
+
+## Mailing list for questions
+
+Usual phonopy questions should be sent to phonopy mailing list
+(https://sourceforge.net/p/phonopy/mailman/).
+
+## Development
+
+The development of phonopy is managed on the `develop` branch of github phonopy
+repository.
+
+- Github issues is the place to discuss about phonopy issues.
+- Github pull request is the place to request merging source code.
+
+### Formatting
+
+Formatting rules are found in `pyproject.toml`.
+
+### pre-commit
+
+Pre-commit (https://pre-commit.com/) is mainly used for applying the formatting
+rules automatically. Therefore, it is strongly encouraged to use it at or before
+git-commit. Pre-commit is set-up and used in the following way:
+
+- Installed by `pip install pre-commit`, `conda install pre_commit` or see
+  https://pre-commit.com/#install.
+- pre-commit hook is installed by `pre-commit install`.
+- pre-commit hook is run by `pre-commit run --all-files`.
+
+Unless running pre-commit, pre-commit.ci may push the fix at PR by github
+action. In this case, the fix should be merged by the contributor's repository.
+
+### VSCode setting
+- Not strictly, but VSCode's `settings.json` may be written like below
+
+  ```json
+  "ruff.lint.args": [
+      "--config=${workspaceFolder}/pyproject.toml",
+  ],
+  "[python]": {
+      "editor.defaultFormatter": "charliermarsh.ruff",
+      "editor.codeActionsOnSave": {
+          "source.organizeImports": "explicit"
+      }
+  },
+  ```
+
+## Documentation
+
+Phonopy user documentation is written using python sphinx. The source files are
+stored in `doc` directory. Please see how to write the documentation at
+`doc/README.md`.
+
+## How to run tests
+
+Tests are written using pytest. To run tests, pytest has to be installed. The
+tests can be run by
+
+```bash
+% pytest
+```

phonopy/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+phonopy Project Package Initialization File
+"""

phonopy/source/build-wheels.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+set -e -u -x
+
+function repair_wheel {
+    wheel="$1"
+    if ! auditwheel show "$wheel"; then
+        echo "Skipping non-platform wheel $wheel"
+    else
+        auditwheel repair "$wheel" --plat "$PLAT" -w /io/wheelhouse/
+    fi
+}
+
+yum install -y hdf5 freetype freetype-devel pkgconfig libpng-devel
+
+
+for PYBIN in /opt/python/*/bin; do
+    if [[ $PYBIN == *"36"* ]] || [[ $PYBIN == *"37"* ]] || [[ $PYBIN == *"38"* ]] || [[ $PYBIN == *"39"* ]]; then
+        "${PYBIN}/pip" install -r /io/dev-requirements.txt
+        "${PYBIN}/pip" wheel /io/ -w wheelhouse/
+    fi
+done
+
+# Bundle external shared libraries into the wheels
+for whl in wheelhouse/phonopy*.whl; do
+    repair_wheel "$whl"
+done
+
+# Install packages and test
+# for PYBIN in /opt/python/*/bin/; do
+#     if [[ $PYBIN == *"36"* ]] || [[ $PYBIN == *"37"* ]] || [[ $PYBIN == *"38"* ]]; then
+#         "${PYBIN}/pip" install phonopy --no-index -f /io/wheelhouse
+#     fi
+# done

phonopy/source/c/_phonopy.cpp

@@ -0,0 +1,599 @@
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <stdint.h>
+
+#include "phonopy.h"
+
+namespace nb = nanobind;
+
+void py_transform_dynmat_to_fc(
+    nb::ndarray<> py_force_constants, nb::ndarray<> py_dynamical_matrices,
+    nb::ndarray<> py_commensurate_points, nb::ndarray<> py_svecs,
+    nb::ndarray<> py_multi, nb::ndarray<> py_masses, nb::ndarray<> py_s2pp_map,
+    nb::ndarray<> py_fc_index_map, int64_t use_openmp) {
+    double *fc;
+    double (*dm)[2];
+    double (*comm_points)[3];
+    double (*svecs)[3];
+    double *masses;
+    int64_t (*multi)[2];
+    int64_t *s2pp_map;
+    int64_t *fc_index_map;
+    int64_t num_patom;
+    int64_t num_satom;
+
+    fc = (double *)py_force_constants.data();
+    dm = (double (*)[2])py_dynamical_matrices.data();
+    comm_points = (double (*)[3])py_commensurate_points.data();
+    svecs = (double (*)[3])py_svecs.data();
+    masses = (double *)py_masses.data();
+    multi = (int64_t (*)[2])py_multi.data();
+    s2pp_map = (int64_t *)py_s2pp_map.data();
+    fc_index_map = (int64_t *)py_fc_index_map.data();
+    num_patom = py_multi.shape(1);
+    num_satom = py_multi.shape(0);
+
+    phpy_transform_dynmat_to_fc(fc, dm, comm_points, svecs, multi, masses,
+                                s2pp_map, fc_index_map, num_patom, num_satom,
+                                use_openmp);
+};
+
+void py_perm_trans_symmetrize_fc(nb::ndarray<> py_force_constants,
+                                 int64_t level) {
+    double *fc;
+    int n_satom;
+
+    fc = (double *)py_force_constants.data();
+    n_satom = py_force_constants.shape(0);
+
+    phpy_perm_trans_symmetrize_fc(fc, n_satom, level);
+}
+
+void py_perm_trans_symmetrize_compact_fc(nb::ndarray<> py_force_constants,
+                                         nb::ndarray<> py_permutations,
+                                         nb::ndarray<> py_s2pp_map,
+                                         nb::ndarray<> py_p2s_map,
+                                         nb::ndarray<> py_nsym_list,
+                                         int64_t level) {
+    double *fc;
+    int *perms;
+    int *s2pp;
+    int *p2s;
+    int *nsym_list;
+    int n_patom, n_satom;
+
+    fc = (double *)py_force_constants.data();
+    perms = (int *)py_permutations.data();
+    s2pp = (int *)py_s2pp_map.data();
+    p2s = (int *)py_p2s_map.data();
+    nsym_list = (int *)py_nsym_list.data();
+    n_patom = py_force_constants.shape(0);
+    n_satom = py_force_constants.shape(1);
+
+    phpy_perm_trans_symmetrize_compact_fc(fc, p2s, s2pp, nsym_list, perms,
+                                          n_satom, n_patom, level);
+}
+
+void py_transpose_compact_fc(nb::ndarray<> py_force_constants,
+                             nb::ndarray<> py_permutations,
+                             nb::ndarray<> py_s2pp_map,
+                             nb::ndarray<> py_p2s_map,
+                             nb::ndarray<> py_nsym_list) {
+    double *fc;
+    int *s2pp;
+    int *p2s;
+    int *nsym_list;
+    int *perms;
+    int n_patom, n_satom;
+
+    fc = (double *)py_force_constants.data();
+    perms = (int *)py_permutations.data();
+    s2pp = (int *)py_s2pp_map.data();
+    p2s = (int *)py_p2s_map.data();
+    nsym_list = (int *)py_nsym_list.data();
+    n_patom = py_force_constants.shape(0);
+    n_satom = py_force_constants.shape(1);
+
+    phpy_set_index_permutation_symmetry_compact_fc(fc, p2s, s2pp, nsym_list,
+                                                   perms, n_satom, n_patom, 1);
+}
+
+void py_get_dynamical_matrices_with_dd_openmp_over_qpoints(
+    nb::ndarray<> py_dynamical_matrix, nb::ndarray<> py_qpoints,
+    nb::ndarray<> py_force_constants, nb::ndarray<> py_svecs,
+    nb::ndarray<> py_multi, nb::ndarray<> py_positions, nb::ndarray<> py_masses,
+    nb::ndarray<> py_s2p_map, nb::ndarray<> py_p2s_map,
+    nb::ndarray<> py_q_direction, nb::ndarray<> py_born,
+    nb::ndarray<> py_dielectric, nb::ndarray<> py_reciprocal_lattice,
+    double nac_factor, nb::ndarray<> py_dd_q0, nb::ndarray<> py_G_list,
+    double lambda, int64_t is_nac, int64_t is_nac_q_zero, int64_t use_Wang_NAC,
+    int64_t hermitianize) {
+    double (*dm)[2];
+    double *fc;
+    double *q_direction;
+    double (*qpoints)[3];
+    double (*svecs)[3];
+    int64_t (*multi)[2];
+    double (*positions)[3];
+    double *masses;
+    double (*born)[3][3];
+    double (*dielectric)[3];
+    double (*reciprocal_lattice)[3];
+    double (*dd_q0)[2];
+    double (*G_list)[3];
+
+    int64_t *s2p_map;
+    int64_t *p2s_map;
+    int64_t num_patom;
+    int64_t num_satom;
+    int64_t n_qpoints;
+    int64_t n_Gpoints;
+
+    dm = (double (*)[2])py_dynamical_matrix.data();
+    qpoints = (double (*)[3])py_qpoints.data();
+    n_qpoints = py_qpoints.shape(0);
+    fc = (double *)py_force_constants.data();
+    svecs = (double (*)[3])py_svecs.data();
+    multi = (int64_t (*)[2])py_multi.data();
+    masses = (double *)py_masses.data();
+    s2p_map = (int64_t *)py_s2p_map.data();
+    p2s_map = (int64_t *)py_p2s_map.data();
+    born = (double (*)[3][3])py_born.data();
+    dielectric = (double (*)[3])py_dielectric.data();
+    reciprocal_lattice = (double (*)[3])py_reciprocal_lattice.data();
+
+    if (use_Wang_NAC || (!is_nac)) {
+        positions = NULL;
+        dd_q0 = NULL;
+        G_list = NULL;
+        n_Gpoints = 0;
+    } else {
+        positions = (double (*)[3])py_positions.data();
+        dd_q0 = (double (*)[2])py_dd_q0.data();
+        G_list = (double (*)[3])py_G_list.data();
+        n_Gpoints = py_G_list.shape(0);
+    }
+
+    if (is_nac_q_zero || (!is_nac)) {
+        q_direction = NULL;
+    } else {
+        q_direction = (double *)py_q_direction.data();
+    }
+
+    num_patom = py_p2s_map.shape(0);
+    num_satom = py_s2p_map.shape(0);
+
+    phpy_dynamical_matrices_with_dd_openmp_over_qpoints(
+        dm, qpoints, n_qpoints, fc, svecs, multi, positions, num_patom,
+        num_satom, masses, p2s_map, s2p_map, born, dielectric,
+        reciprocal_lattice, q_direction, nac_factor, dd_q0, G_list, n_Gpoints,
+        lambda, use_Wang_NAC, hermitianize);
+}
+
+void py_get_recip_dipole_dipole(
+    nb::ndarray<> py_dd, nb::ndarray<> py_dd_q0, nb::ndarray<> py_G_list,
+    nb::ndarray<> py_q_cart, nb::ndarray<> py_q_direction,
+    nb::ndarray<> py_born, nb::ndarray<> py_dielectric,
+    nb::ndarray<> py_positions, int64_t is_nac_q_zero, double factor,
+    double lambda, double tolerance, int64_t use_openmp) {
+    double (*dd)[2];
+    double (*dd_q0)[2];
+    double (*G_list)[3];
+    double *q_vector;
+    double *q_direction;
+    double (*born)[3][3];
+    double (*dielectric)[3];
+    double (*pos)[3];
+
+    int64_t num_patom, num_G;
+
+    dd = (double (*)[2])py_dd.data();
+    dd_q0 = (double (*)[2])py_dd_q0.data();
+    G_list = (double (*)[3])py_G_list.data();
+    if (is_nac_q_zero) {
+        q_direction = NULL;
+    } else {
+        q_direction = (double *)py_q_direction.data();
+    }
+    q_vector = (double *)py_q_cart.data();
+    born = (double (*)[3][3])py_born.data();
+    dielectric = (double (*)[3])py_dielectric.data();
+    pos = (double (*)[3])py_positions.data();
+    num_G = py_G_list.shape(0);
+    num_patom = py_positions.shape(0);
+
+    phpy_get_recip_dipole_dipole(dd,    /* [natom, 3, natom, 3, (real, imag)] */
+                                 dd_q0, /* [natom, 3, 3, (real, imag)] */
+                                 G_list, /* [num_kvec, 3] */
+                                 num_G, num_patom, q_vector, q_direction, born,
+                                 dielectric, pos, /* [natom, 3] */
+                                 factor,          /* 4pi/V*unit-conv */
+                                 lambda,          /* 4 * Lambda^2 */
+                                 tolerance, use_openmp);
+}
+
+void py_get_recip_dipole_dipole_q0(nb::ndarray<> py_dd_q0,
+                                   nb::ndarray<> py_G_list,
+                                   nb::ndarray<> py_born,
+                                   nb::ndarray<> py_dielectric,
+                                   nb::ndarray<> py_positions, double lambda,
+                                   double tolerance, int64_t use_openmp) {
+    double (*dd_q0)[2];
+    double (*G_list)[3];
+    double (*born)[3][3];
+    double (*dielectric)[3];
+    double (*pos)[3];
+
+    int64_t num_patom, num_G;
+
+    dd_q0 = (double (*)[2])py_dd_q0.data();
+    G_list = (double (*)[3])py_G_list.data();
+    born = (double (*)[3][3])py_born.data();
+    dielectric = (double (*)[3])py_dielectric.data();
+    pos = (double (*)[3])py_positions.data();
+    num_G = py_G_list.shape(0);
+    num_patom = py_positions.shape(0);
+
+    phpy_get_recip_dipole_dipole_q0(dd_q0,  /* [natom, 3, 3, (real, imag)] */
+                                    G_list, /* [num_kvec, 3] */
+                                    num_G, num_patom, born, dielectric,
+                                    pos,    /* [natom, 3] */
+                                    lambda, /* 4 * Lambda^2 */
+                                    tolerance, use_openmp);
+}
+
+void py_get_derivative_dynmat(
+    nb::ndarray<> py_derivative_dynmat, nb::ndarray<> py_force_constants,
+    nb::ndarray<> py_q_vector, nb::ndarray<> py_lattice,
+    nb::ndarray<> py_reclat, nb::ndarray<> py_svecs, nb::ndarray<> py_multi,
+    nb::ndarray<> py_masses, nb::ndarray<> py_s2p_map, nb::ndarray<> py_p2s_map,
+    double nac_factor, nb::ndarray<> py_born, nb::ndarray<> py_dielectric,
+    nb::ndarray<> py_q_direction, int64_t is_nac, int64_t is_nac_q_zero,
+    int64_t use_openmp) {
+    double (*ddm)[2];
+    double *fc;
+    double *q_vector;
+    double *lattice;
+    double *reclat;
+    double (*svecs)[3];
+    double *masses;
+    int64_t (*multi)[2];
+    int64_t *s2p_map;
+    int64_t *p2s_map;
+    int64_t num_patom;
+    int64_t num_satom;
+
+    double *born;
+    double *epsilon;
+    double *q_dir;
+
+    ddm = (double (*)[2])py_derivative_dynmat.data();
+    fc = (double *)py_force_constants.data();
+    q_vector = (double *)py_q_vector.data();
+    lattice = (double *)py_lattice.data();
+    reclat = (double *)py_reclat.data();
+    svecs = (double (*)[3])py_svecs.data();
+    masses = (double *)py_masses.data();
+    multi = (int64_t (*)[2])py_multi.data();
+    s2p_map = (int64_t *)py_s2p_map.data();
+    p2s_map = (int64_t *)py_p2s_map.data();
+    num_patom = py_p2s_map.shape(0);
+    num_satom = py_s2p_map.shape(0);
+
+    epsilon = (double *)py_dielectric.data();
+    born = (double *)py_born.data();
+    if (is_nac_q_zero) {
+        q_dir = NULL;
+    } else {
+        q_dir = (double *)py_q_direction.data();
+    }
+
+    phpy_get_derivative_dynmat_at_q(ddm, num_patom, num_satom, fc, q_vector,
+                                    lattice, reclat, svecs, multi, masses,
+                                    s2p_map, p2s_map, nac_factor, born, epsilon,
+                                    q_dir, is_nac, use_openmp);
+}
+
+void py_get_thermal_properties(nb::ndarray<> py_thermal_props,
+                               nb::ndarray<> py_temperatures,
+                               nb::ndarray<> py_frequencies,
+                               nb::ndarray<> py_weights,
+                               double cutoff_frequency, double KB,
+                               int classical) {
+    double *temperatures;
+    double *freqs;
+    double *thermal_props;
+    int64_t *weights;
+    int64_t num_qpoints;
+    int64_t num_bands;
+    int64_t num_temp;
+
+    thermal_props = (double *)py_thermal_props.data();
+    temperatures = (double *)py_temperatures.data();
+    num_temp = (int64_t)py_temperatures.shape(0);
+    freqs = (double *)py_frequencies.data();
+    num_qpoints = (int64_t)py_frequencies.shape(0);
+    weights = (int64_t *)py_weights.data();
+    num_bands = (int64_t)py_frequencies.shape(1);
+
+    phpy_get_thermal_properties(thermal_props, temperatures, freqs, weights,
+                                num_temp, num_qpoints, num_bands,
+                                cutoff_frequency, KB, classical);
+}
+
+void py_distribute_fc2(nb::ndarray<> py_force_constants,
+                       nb::ndarray<> py_atom_list,
+                       nb::ndarray<> py_fc_indices_of_atom_list,
+                       nb::ndarray<> py_rotations_cart,
+                       nb::ndarray<> py_permutations,
+                       nb::ndarray<> py_map_atoms, nb::ndarray<> py_map_syms) {
+    double (*r_carts)[3][3];
+    double (*fc2)[3][3];
+    int *permutations;
+    int *map_atoms;
+    int *map_syms;
+    int *atom_list;
+    int *fc_indices_of_atom_list;
+    int64_t num_pos, num_rot, len_atom_list;
+
+    fc2 = (double (*)[3][3])py_force_constants.data();
+    atom_list = (int *)py_atom_list.data();
+    len_atom_list = py_atom_list.shape(0);
+    fc_indices_of_atom_list = (int *)py_fc_indices_of_atom_list.data();
+    permutations = (int *)py_permutations.data();
+    map_atoms = (int *)py_map_atoms.data();
+    map_syms = (int *)py_map_syms.data();
+    r_carts = (double (*)[3][3])py_rotations_cart.data();
+    num_rot = py_permutations.shape(0);
+    num_pos = py_permutations.shape(1);
+
+    phpy_distribute_fc2(fc2, atom_list, len_atom_list, fc_indices_of_atom_list,
+                        r_carts, permutations, map_atoms, map_syms, num_rot,
+                        num_pos);
+}
+
+bool py_compute_permutation(nb::ndarray<> permutation, nb::ndarray<> lattice,
+                            nb::ndarray<> positions,
+                            nb::ndarray<> permuted_positions, double symprec) {
+    int *rot_atoms;
+    double (*lat)[3];
+    double (*pos)[3];
+    double (*rot_pos)[3];
+    int num_pos;
+
+    int is_found;
+
+    rot_atoms = (int *)permutation.data();
+    lat = (double (*)[3])lattice.data();
+    pos = (double (*)[3])positions.data();
+    rot_pos = (double (*)[3])permuted_positions.data();
+    num_pos = positions.shape(0);
+
+    is_found = phpy_compute_permutation(rot_atoms, lat, pos, rot_pos, num_pos,
+                                        symprec);
+
+    if (is_found) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void py_gsv_set_smallest_vectors_sparse(
+    nb::ndarray<> py_smallest_vectors, nb::ndarray<> py_multiplicity,
+    nb::ndarray<> py_pos_to, nb::ndarray<> py_pos_from,
+    nb::ndarray<> py_lattice_points, nb::ndarray<> py_reduced_basis,
+    nb::ndarray<> py_trans_mat, double symprec) {
+    double (*smallest_vectors)[27][3];
+    int *multiplicity;
+    double (*pos_to)[3];
+    double (*pos_from)[3];
+    int (*lattice_points)[3];
+    double (*reduced_basis)[3];
+    int (*trans_mat)[3];
+    int num_pos_to, num_pos_from, num_lattice_points;
+
+    smallest_vectors = (double (*)[27][3])py_smallest_vectors.data();
+    multiplicity = (int *)py_multiplicity.data();
+    pos_to = (double (*)[3])py_pos_to.data();
+    pos_from = (double (*)[3])py_pos_from.data();
+    num_pos_to = py_pos_to.shape(0);
+    num_pos_from = py_pos_from.shape(0);
+    lattice_points = (int (*)[3])py_lattice_points.data();
+    num_lattice_points = py_lattice_points.shape(0);
+    reduced_basis = (double (*)[3])py_reduced_basis.data();
+    trans_mat = (int (*)[3])py_trans_mat.data();
+
+    phpy_set_smallest_vectors_sparse(smallest_vectors, multiplicity, pos_to,
+                                     num_pos_to, pos_from, num_pos_from,
+                                     lattice_points, num_lattice_points,
+                                     reduced_basis, trans_mat, symprec);
+}
+
+void py_gsv_set_smallest_vectors_dense(
+    nb::ndarray<> py_smallest_vectors, nb::ndarray<> py_multiplicity,
+    nb::ndarray<> py_pos_to, nb::ndarray<> py_pos_from,
+    nb::ndarray<> py_lattice_points, nb::ndarray<> py_reduced_basis,
+    nb::ndarray<> py_trans_mat, int64_t initialize, double symprec) {
+    double (*smallest_vectors)[3];
+    int64_t (*multiplicity)[2];
+    double (*pos_to)[3];
+    double (*pos_from)[3];
+    int64_t (*lattice_points)[3];
+    double (*reduced_basis)[3];
+    int64_t (*trans_mat)[3];
+    int64_t num_pos_to, num_pos_from, num_lattice_points;
+
+    smallest_vectors = (double (*)[3])py_smallest_vectors.data();
+    multiplicity = (int64_t (*)[2])py_multiplicity.data();
+    pos_to = (double (*)[3])py_pos_to.data();
+    pos_from = (double (*)[3])py_pos_from.data();
+    num_pos_to = py_pos_to.shape(0);
+    num_pos_from = py_pos_from.shape(0);
+    lattice_points = (int64_t (*)[3])py_lattice_points.data();
+    num_lattice_points = py_lattice_points.shape(0);
+    reduced_basis = (double (*)[3])py_reduced_basis.data();
+    trans_mat = (int64_t (*)[3])py_trans_mat.data();
+
+    phpy_set_smallest_vectors_dense(
+        smallest_vectors, multiplicity, pos_to, num_pos_to, pos_from,
+        num_pos_from, lattice_points, num_lattice_points, reduced_basis,
+        trans_mat, initialize, symprec);
+}
+
+void py_thm_relative_grid_address(nb::ndarray<> py_relative_grid_address,
+                                  nb::ndarray<> py_reciprocal_lattice_py) {
+    int64_t (*relative_grid_address)[4][3];
+    double (*reciprocal_lattice)[3];
+
+    relative_grid_address = (int64_t (*)[4][3])py_relative_grid_address.data();
+    reciprocal_lattice = (double (*)[3])py_reciprocal_lattice_py.data();
+
+    phpy_get_relative_grid_address(relative_grid_address, reciprocal_lattice);
+}
+
+void py_thm_all_relative_grid_address(nb::ndarray<> py_relative_grid_address) {
+    int64_t (*relative_grid_address)[24][4][3];
+
+    relative_grid_address =
+        (int64_t (*)[24][4][3])py_relative_grid_address.data();
+
+    phpy_get_all_relative_grid_address(relative_grid_address);
+}
+
+double py_thm_integration_weight(double omega,
+                                 nb::ndarray<> py_tetrahedra_omegas,
+                                 const char *function) {
+    double (*tetrahedra_omegas)[4];
+    double iw;
+
+    tetrahedra_omegas = (double (*)[4])py_tetrahedra_omegas.data();
+
+    iw = phpy_get_integration_weight(omega, tetrahedra_omegas, function[0]);
+
+    return iw;
+}
+
+void py_thm_integration_weight_at_omegas(nb::ndarray<> py_integration_weights,
+                                         nb::ndarray<> py_omegas,
+                                         nb::ndarray<> py_tetrahedra_omegas,
+                                         const char *function) {
+    double *omegas;
+    double *iw;
+    int64_t num_omegas;
+    double (*tetrahedra_omegas)[4];
+
+    int64_t i;
+
+    omegas = (double *)py_omegas.data();
+    iw = (double *)py_integration_weights.data();
+    num_omegas = (int64_t)py_omegas.shape(0);
+    tetrahedra_omegas = (double (*)[4])py_tetrahedra_omegas.data();
+
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+    for (i = 0; i < num_omegas; i++) {
+        iw[i] = phpy_get_integration_weight(omegas[i], tetrahedra_omegas,
+                                            function[0]);
+    }
+}
+
+void py_get_tetrahedra_frequenies(nb::ndarray<> py_freq_tetras,
+                                  nb::ndarray<> py_grid_points,
+                                  nb::ndarray<> py_mesh,
+                                  nb::ndarray<> py_grid_address,
+                                  nb::ndarray<> py_gp_ir_index,
+                                  nb::ndarray<> py_relative_grid_address,
+                                  nb::ndarray<> py_frequencies) {
+    double *freq_tetras;
+    int64_t *grid_points;
+    int64_t *mesh;
+    int64_t (*grid_address)[3];
+    int64_t *gp_ir_index;
+    int64_t (*relative_grid_address)[3];
+    double *frequencies;
+
+    int64_t num_gp_in, num_band;
+
+    freq_tetras = (double *)py_freq_tetras.data();
+    grid_points = (int64_t *)py_grid_points.data();
+    num_gp_in = py_grid_points.shape(0);
+    mesh = (int64_t *)py_mesh.data();
+    grid_address = (int64_t (*)[3])py_grid_address.data();
+    gp_ir_index = (int64_t *)py_gp_ir_index.data();
+    relative_grid_address = (int64_t (*)[3])py_relative_grid_address.data();
+    frequencies = (double *)py_frequencies.data();
+    num_band = py_frequencies.shape(1);
+
+    phpy_get_tetrahedra_frequenies(freq_tetras, mesh, grid_points, grid_address,
+                                   relative_grid_address, gp_ir_index,
+                                   frequencies, num_band, num_gp_in);
+}
+
+void py_tetrahedron_method_dos(nb::ndarray<> py_dos, nb::ndarray<> py_mesh,
+                               nb::ndarray<> py_freq_points,
+                               nb::ndarray<> py_frequencies,
+                               nb::ndarray<> py_coef,
+                               nb::ndarray<> py_grid_address,
+                               nb::ndarray<> py_grid_mapping_table,
+                               nb::ndarray<> py_relative_grid_address) {
+    double *dos;
+    int64_t *mesh;
+    double *freq_points;
+    double *frequencies;
+    double *coef;
+    int64_t (*grid_address)[3];
+    int64_t num_gp, num_ir_gp, num_band, num_freq_points, num_coef;
+    int64_t *grid_mapping_table;
+    int64_t (*relative_grid_address)[4][3];
+
+    /* dos[num_ir_gp][num_band][num_freq_points][num_coef] */
+    dos = (double *)py_dos.data();
+    mesh = (int64_t *)py_mesh.data();
+    freq_points = (double *)py_freq_points.data();
+    num_freq_points = (int64_t)py_freq_points.shape(0);
+    frequencies = (double *)py_frequencies.data();
+    num_ir_gp = (int64_t)py_frequencies.shape(0);
+    num_band = (int64_t)py_frequencies.shape(1);
+    coef = (double *)py_coef.data();
+    num_coef = (int64_t)py_coef.shape(1);
+    grid_address = (int64_t (*)[3])py_grid_address.data();
+    num_gp = (int64_t)py_grid_address.shape(0);
+    grid_mapping_table = (int64_t *)py_grid_mapping_table.data();
+    relative_grid_address = (int64_t (*)[4][3])py_relative_grid_address.data();
+
+    phpy_tetrahedron_method_dos(dos, mesh, grid_address, relative_grid_address,
+                                grid_mapping_table, freq_points, frequencies,
+                                coef, num_freq_points, num_ir_gp, num_band,
+                                num_coef, num_gp);
+}
+
+NB_MODULE(_phonopy, m) {
+    m.def("transform_dynmat_to_fc", &py_transform_dynmat_to_fc);
+    m.def("perm_trans_symmetrize_fc", &py_perm_trans_symmetrize_fc);
+    m.def("perm_trans_symmetrize_compact_fc",
+          &py_perm_trans_symmetrize_compact_fc);
+    m.def("transpose_compact_fc", &py_transpose_compact_fc);
+    m.def("dynamical_matrices_with_dd_openmp_over_qpoints",
+          &py_get_dynamical_matrices_with_dd_openmp_over_qpoints);
+    m.def("recip_dipole_dipole", &py_get_recip_dipole_dipole);
+    m.def("recip_dipole_dipole_q0", &py_get_recip_dipole_dipole_q0);
+    m.def("derivative_dynmat", &py_get_derivative_dynmat);
+    m.def("thermal_properties", &py_get_thermal_properties);
+    m.def("distribute_fc2", &py_distribute_fc2);
+    m.def("compute_permutation", &py_compute_permutation);
+    m.def("gsv_set_smallest_vectors_sparse",
+          &py_gsv_set_smallest_vectors_sparse);
+    m.def("gsv_set_smallest_vectors_dense", &py_gsv_set_smallest_vectors_dense);
+    m.def("tetrahedra_relative_grid_address", &py_thm_relative_grid_address);
+    m.def("all_tetrahedra_relative_grid_address",
+          &py_thm_all_relative_grid_address);
+    m.def("tetrahedra_integration_weight", &py_thm_integration_weight);
+    m.def("tetrahedra_integration_weight_at_omegas",
+          &py_thm_integration_weight_at_omegas);
+    m.def("tetrahedra_frequencies", &py_get_tetrahedra_frequenies);
+    m.def("tetrahedron_method_dos", &py_tetrahedron_method_dos);
+    m.def("use_openmp", &phpy_use_openmp);
+    m.def("omp_max_threads", &phpy_get_max_threads);
+}

phonopy/source/c/derivative_dynmat.c

@@ -0,0 +1,341 @@
+/* Copyright (C) 2015 Atsushi Togo */
+/* All rights reserved. */
+
+/* This file is part of phonopy. */
+
+/* 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. */
+
+#include "derivative_dynmat.h"
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PI 3.14159265358979323846
+
+static void get_derivative_dynmat_at_q(
+    double (*derivative_dynmat)[2], const int64_t i, const int64_t j,
+    const double *ddnac, const double *dnac, const int64_t is_nac,
+    const int64_t num_patom, const int64_t num_satom, const double *fc,
+    const double *q, const double *lattice, /* column vector */
+    const double (*svecs)[3], const int64_t (*multi)[2], const double *mass,
+    const int64_t *s2p_map, const int64_t *p2s_map);
+static void get_derivative_nac(double *ddnac, double *dnac,
+                               const int64_t num_patom, const double *lattice,
+                               const double *mass, const double *q,
+                               const double *born, const double *dielectric,
+                               const double *q_direction, const double factor);
+static double get_A(const int64_t atom_i, const int64_t cart_i,
+                    const double q[3], const double *born);
+static double get_C(const double q[3], const double *dielectric);
+static double get_dA(const int64_t atom_i, const int64_t cart_i,
+                     const int64_t cart_j, const double *born);
+static double get_dC(const int64_t cart_i, const int64_t cart_j,
+                     const int64_t cart_k, const double q[3],
+                     const double *dielectric);
+
+void ddm_get_derivative_dynmat_at_q(
+    double (*derivative_dynmat)[2], const int64_t num_patom,
+    const int64_t num_satom, const double *fc, const double *q,
+    const double *lattice, /* column vector */
+    const double *reclat,  /* column vector */
+    const double (*svecs)[3], const int64_t (*multi)[2], const double *mass,
+    const int64_t *s2p_map, const int64_t *p2s_map, const double nac_factor,
+    const double *born, const double *dielectric, const double *q_direction,
+    const int64_t is_nac, const int64_t use_openmp) {
+    int64_t i, j, k, ij, adrs, adrsT;
+    double factor;
+    double *ddnac, *dnac;
+
+    if (is_nac) {
+        ddnac = (double *)malloc(sizeof(double) * num_patom * num_patom * 27);
+        dnac = (double *)malloc(sizeof(double) * num_patom * num_patom * 9);
+        factor = (nac_factor * num_patom) / num_satom;
+        get_derivative_nac(ddnac, dnac, num_patom, reclat, mass, q, born,
+                           dielectric, q_direction, factor);
+    }
+
+    if (use_openmp) {
+#ifdef _OPENMP
+#pragma omp parallel for private(i, j)
+#endif
+        for (ij = 0; ij < num_patom * num_patom; ij++) {
+            i = ij / num_patom;
+            j = ij % num_patom;
+            get_derivative_dynmat_at_q(derivative_dynmat, i, j, ddnac, dnac,
+                                       is_nac, num_patom, num_satom, fc, q,
+                                       lattice, svecs, multi, mass, s2p_map,
+                                       p2s_map);
+        }
+    } else {
+        for (i = 0; i < num_patom; i++) {
+            for (j = 0; j < num_patom; j++) {
+                get_derivative_dynmat_at_q(derivative_dynmat, i, j, ddnac, dnac,
+                                           is_nac, num_patom, num_satom, fc, q,
+                                           lattice, svecs, multi, mass, s2p_map,
+                                           p2s_map);
+            }
+        }
+    }
+
+    /* Symmetrize to be a Hermitian matrix */
+    for (i = 0; i < 3; i++) {
+        for (j = i; j < num_patom * 3; j++) {
+            for (k = 0; k < num_patom * 3; k++) {
+                adrs = i * num_patom * num_patom * 9 + j * num_patom * 3 + k;
+                adrsT = i * num_patom * num_patom * 9 + k * num_patom * 3 + j;
+                derivative_dynmat[adrs][0] += derivative_dynmat[adrsT][0];
+                derivative_dynmat[adrs][0] /= 2;
+                derivative_dynmat[adrs][1] -= derivative_dynmat[adrsT][1];
+                derivative_dynmat[adrs][1] /= 2;
+                derivative_dynmat[adrsT][0] = derivative_dynmat[adrs][0];
+                derivative_dynmat[adrsT][1] = -derivative_dynmat[adrs][1];
+            }
+        }
+    }
+
+    if (is_nac) {
+        free(ddnac);
+        ddnac = NULL;
+        free(dnac);
+        dnac = NULL;
+    }
+}
+
+void get_derivative_dynmat_at_q(
+    double (*derivative_dynmat)[2], const int64_t i, const int64_t j,
+    const double *ddnac, const double *dnac, const int64_t is_nac,
+    const int64_t num_patom, const int64_t num_satom, const double *fc,
+    const double *q, const double *lattice, /* column vector */
+    const double (*svecs)[3], const int64_t (*multi)[2], const double *mass,
+    const int64_t *s2p_map, const int64_t *p2s_map) {
+    int64_t k, l, m, n, adrs, m_pair, i_pair, svecs_adrs;
+    double coef[3], real_coef[3], imag_coef[3];
+    double c, s, phase, mass_sqrt, fc_elem, real_phase, imag_phase;
+    double ddm_real[3][3][3], ddm_imag[3][3][3];
+
+    mass_sqrt = sqrt(mass[i] * mass[j]);
+
+    for (k = 0; k < 3; k++) {
+        for (l = 0; l < 3; l++) {
+            for (m = 0; m < 3; m++) {
+                ddm_real[m][k][l] = 0;
+                ddm_imag[m][k][l] = 0;
+            }
+        }
+    }
+
+    for (k = 0; k < num_satom; k++) { /* Lattice points of right index of fc */
+        if (s2p_map[k] != p2s_map[j]) {
+            continue;
+        }
+
+        real_phase = 0;
+        imag_phase = 0;
+        for (l = 0; l < 3; l++) {
+            real_coef[l] = 0;
+            imag_coef[l] = 0;
+        }
+        i_pair = k * num_patom + i;
+        m_pair = multi[i_pair][0];
+        svecs_adrs = multi[i_pair][1];
+        for (l = 0; l < m_pair; l++) {
+            phase = 0;
+            for (m = 0; m < 3; m++) {
+                phase += q[m] * svecs[svecs_adrs + l][m];
+            }
+            s = sin(phase * 2 * PI);
+            c = cos(phase * 2 * PI);
+
+            real_phase += c;
+            imag_phase += s;
+
+            for (m = 0; m < 3; m++) {
+                coef[m] = 0;
+                for (n = 0; n < 3; n++) {
+                    coef[m] +=
+                        2 * PI * lattice[m * 3 + n] * svecs[svecs_adrs + l][n];
+                }
+            }
+
+            for (m = 0; m < 3; m++) {
+                real_coef[m] -= coef[m] * s;
+                imag_coef[m] += coef[m] * c;
+            }
+        }
+
+        real_phase /= m_pair;
+        imag_phase /= m_pair;
+
+        for (l = 0; l < 3; l++) {
+            real_coef[l] /= m_pair;
+            imag_coef[l] /= m_pair;
+        }
+
+        for (l = 0; l < 3; l++) {
+            for (m = 0; m < 3; m++) {
+                fc_elem = fc[p2s_map[i] * num_satom * 9 + k * 9 + l * 3 + m] /
+                          mass_sqrt;
+                if (is_nac) {
+                    fc_elem += dnac[i * 9 * num_patom + j * 9 + l * 3 + m];
+                }
+                for (n = 0; n < 3; n++) {
+                    ddm_real[n][l][m] += fc_elem * real_coef[n];
+                    ddm_imag[n][l][m] += fc_elem * imag_coef[n];
+                    if (is_nac) {
+                        ddm_real[n][l][m] +=
+                            ddnac[n * num_patom * num_patom * 9 +
+                                  i * 9 * num_patom + j * 9 + l * 3 + m] *
+                            real_phase;
+                        ddm_imag[n][l][m] +=
+                            ddnac[n * num_patom * num_patom * 9 +
+                                  i * 9 * num_patom + j * 9 + l * 3 + m] *
+                            imag_phase;
+                    }
+                }
+            }
+        }
+    }
+
+    for (k = 0; k < 3; k++) {
+        for (l = 0; l < 3; l++) {
+            for (m = 0; m < 3; m++) {
+                adrs = (k * num_patom * num_patom * 9 +
+                        (i * 3 + l) * num_patom * 3 + j * 3 + m * 1);
+                derivative_dynmat[adrs][0] += ddm_real[k][l][m];
+                derivative_dynmat[adrs][1] += ddm_imag[k][l][m];
+            }
+        }
+    }
+}
+
+/* D_nac = a * AB/C */
+/* dD_nac = a * D_nac * (A'/A + B'/B - C'/C) */
+static void get_derivative_nac(double *ddnac, double *dnac,
+                               const int64_t num_patom, const double *reclat,
+                               const double *mass, const double *q,
+                               const double *born, const double *dielectric,
+                               const double *q_direction, const double factor) {
+    int64_t i, j, k, l, m;
+    double a, b, c, da, db, dc, mass_sqrt;
+    double q_cart[3];
+
+    for (i = 0; i < 3; i++) {
+        q_cart[i] = 0;
+        for (j = 0; j < 3; j++) {
+            if (q_direction) {
+                q_cart[i] += reclat[i * 3 + j] * q_direction[j];
+            } else {
+                q_cart[i] += reclat[i * 3 + j] * q[j];
+            }
+        }
+    }
+
+    c = get_C(q_cart, dielectric);
+
+    for (i = 0; i < num_patom; i++) {     /* atom_i */
+        for (j = 0; j < num_patom; j++) { /* atom_j */
+            mass_sqrt = sqrt(mass[i] * mass[j]);
+            for (k = 0; k < 3; k++) {     /* derivative direction */
+                for (l = 0; l < 3; l++) { /* alpha */
+                    a = get_A(i, l, q_cart, born);
+                    da = get_dA(i, l, k, born);
+                    for (m = 0; m < 3; m++) { /* beta */
+                        b = get_A(j, m, q_cart, born);
+                        db = get_dA(j, m, k, born);
+                        dc = get_dC(l, m, k, q_cart, dielectric);
+                        ddnac[k * num_patom * num_patom * 9 +
+                              i * 9 * num_patom + j * 9 + l * 3 + m] =
+                            (da * b + db * a - a * b * dc / c) /
+                            (c * mass_sqrt) * factor;
+                        if (k == 0) {
+                            dnac[i * 9 * num_patom + j * 9 + l * 3 + m] =
+                                a * b / (c * mass_sqrt) * factor;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+static double get_A(const int64_t atom_i, const int64_t cart_i,
+                    const double q[3], const double *born) {
+    int64_t i;
+    double sum;
+
+    sum = 0;
+    for (i = 0; i < 3; i++) {
+        sum += q[i] * born[atom_i * 9 + i * 3 + cart_i];
+    }
+
+    return sum;
+}
+
+static double get_C(const double q[3], const double *dielectric) {
+    int64_t i, j;
+    double sum;
+
+    sum = 0;
+    for (i = 0; i < 3; i++) {
+        for (j = 0; j < 3; j++) {
+            sum += q[i] * dielectric[i * 3 + j] * q[j];
+        }
+    }
+
+    return sum;
+}
+
+static double get_dA(const int64_t atom_i, const int64_t cart_i,
+                     const int64_t cart_j, const double *born) {
+    return born[atom_i * 9 + cart_j * 3 + cart_i];
+}
+
+static double get_dC(const int64_t cart_i, const int64_t cart_j,
+                     const int64_t cart_k, const double q[3],
+                     const double *dielectric) {
+    if (cart_k == 0) {
+        return (2 * q[0] * dielectric[0] +
+                q[1] * (dielectric[1] + dielectric[3]) +
+                q[2] * (dielectric[2] + dielectric[6]));
+    }
+    if (cart_k == 1) {
+        return (2 * q[1] * dielectric[4] +
+                q[2] * (dielectric[5] + dielectric[7]) +
+                q[0] * (dielectric[1] + dielectric[3]));
+    }
+    if (cart_k == 2) {
+        return (2 * q[2] * dielectric[8] +
+                q[0] * (dielectric[2] + dielectric[6]) +
+                q[1] * (dielectric[5] + dielectric[7]));
+    }
+    return 0;
+}

phonopy/source/c/derivative_dynmat.h

@@ -0,0 +1,50 @@
+/* Copyright (C) 2015 Atsushi Togo */
+/* All rights reserved. */
+
+/* This file is part of phonopy. */
+
+/* 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 __derivative_dynmat_H__
+#define __derivative_dynmat_H__
+
+#include <stdint.h>
+
+void ddm_get_derivative_dynmat_at_q(
+    double (*derivative_dynmat)[2], const int64_t num_patom,
+    const int64_t num_satom, const double *fc, const double *q,
+    const double *lattice, /* column vector */
+    const double *reclat,  /* column vector */
+    const double (*svecs)[3], const int64_t (*multi)[2], const double *mass,
+    const int64_t *s2p_map, const int64_t *p2s_map, const double nac_factor,
+    const double *born, const double *dielectric, const double *q_direction,
+    const int64_t is_nac, const int64_t use_openmp);
+
+#endif

phonopy/source/c/dynmat.c

@@ -0,0 +1,822 @@
+/* Copyright (C) 2015 Atsushi Togo */
+/* All rights reserved. */
+
+/* This file is part of phonopy. */
+
+/* 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. */
+
+#include "dynmat.h"
+
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define PI 3.14159265358979323846
+
+static int64_t get_dynamical_matrix_at_q(
+    double (*dynamical_matrix)[2], const int64_t num_patom,
+    const int64_t num_satom, const double *fc, const double q[3],
+    const double (*svecs)[3], const int64_t (*multi)[2], const double *mass,
+    const int64_t *s2p_map, const int64_t *p2s_map,
+    const double (*charge_sum)[3][3], const int64_t hermitianize,
+    const int64_t use_openmp);
+static void add_dynmat_dd_at_q(
+    double (*dynamical_matrices)[2], const double q[3], const double *fc,
+    const double (*positions)[3], const int64_t num_patom, const double *masses,
+    const double (*born)[3][3], const double dielectric[3][3],
+    const double reciprocal_lattice[3][3], const double *q_dir_cart,
+    const double nac_factor, const double (*dd_q0)[2],
+    const double (*G_list)[3], const int64_t num_G_points, const double lambda,
+    const double tolerance);
+static void get_dynmat_ij(double (*dynamical_matrix)[2],
+                          const int64_t num_patom, const int64_t num_satom,
+                          const double *fc, const double q[3],
+                          const double (*svecs)[3], const int64_t (*multi)[2],
+                          const double *mass, const int64_t *s2p_map,
+                          const int64_t *p2s_map,
+                          const double (*charge_sum)[3][3], const int64_t i,
+                          const int64_t j);
+static void get_dm(double dm[3][3][2], const int64_t num_patom,
+                   const int64_t num_satom, const double *fc, const double q[3],
+                   const double (*svecs)[3], const int64_t (*multi)[2],
+                   const int64_t *p2s_map, const double (*charge_sum)[3][3],
+                   const int64_t i, const int64_t j, const int64_t k);
+static double get_dielectric_part(const double q_cart[3],
+                                  const double dielectric[3][3]);
+static void get_dd(double (*dd_part)[2], /* [natom, 3, natom, 3, (real,imag)] */
+                   const double (*G_list)[3], /* [num_G, 3] */
+                   const int64_t num_G, const int64_t num_patom,
+                   const double q_cart[3], const double *q_direction_cart,
+                   const double dielectric[3][3],
+                   const double (*pos)[3], /* [num_patom, 3] */
+                   const double lambda, const double tolerance,
+                   const int64_t use_openmp);
+static void get_dd_at_g(
+    double (*dd_part)[2], /* [natom, 3, natom, 3, (real,imag)] */
+    const int64_t i, const int64_t j, const double G[3],
+    const int64_t num_patom, const double (*pos)[3], /* [num_patom, 3] */
+    const double KK[3][3]);
+static void make_Hermitian(double (*mat)[2], const int64_t num_band);
+static void multiply_borns(double (*dd)[2], const double (*dd_in)[2],
+                           const int64_t num_patom, const double (*born)[3][3],
+                           const int64_t use_openmp);
+static void multiply_borns_at_ij(double (*dd)[2], const int64_t i,
+                                 const int64_t j, const double (*dd_in)[2],
+                                 const int64_t num_patom,
+                                 const double (*born)[3][3]);
+static void transform_dynmat_to_fc_ij(
+    double *fc, const double (*dm)[2], const int64_t i, const int64_t j,
+    const double (*comm_points)[3], const double (*svecs)[3],
+    const int64_t (*multi)[2], const double *masses, const int64_t *s2pp_map,
+    const int64_t *fc_index_map, const int64_t num_patom,
+    const int64_t num_satom);
+static void get_q_cart(double q_cart[3], const double q[3],
+                       const double reciprocal_lattice[3][3]);
+static void get_dynmat_wang(
+    double (*dynamical_matrices)[2], const double qpoint[3], const double *fc,
+    const double (*svecs)[3], const int64_t (*multi)[2],
+    const int64_t num_patom, const int64_t num_satom, const double *masses,
+    const int64_t *p2s_map, const int64_t *s2p_map, const double (*born)[3][3],
+    const double dielectric[3][3], const double (*reciprocal_lattice)[3],
+    const double *q_direction, const double *q_dir_cart,
+    const double nac_factor, const double q_zero_tolerance,
+    const int64_t hermitianize);
+
+/// @brief Calculate dynamical matrices with openmp over q-points
+/// use_Wang_NAC: Wang et al.
+/// !use_Wang_NAC and dd_0 is NULL: no-NAC
+/// !use_Wang_NAC and dd_0 is not NULL: NAC by Gonze and Lee.
+/// @param reciprocal_lattice in column vectors
+/// @param q_direction in Crystallographic coordinates.
+int64_t dym_dynamical_matrices_with_dd_openmp_over_qpoints(
+    double (*dynamical_matrices)[2], const double (*qpoints)[3],
+    const int64_t n_qpoints, const double *fc, const double (*svecs)[3],
+    const int64_t (*multi)[2], const double (*positions)[3],
+    const int64_t num_patom, const int64_t num_satom, const double *masses,
+    const int64_t *p2s_map, const int64_t *s2p_map, const double (*born)[3][3],
+    const double dielectric[3][3], const double (*reciprocal_lattice)[3],
+    const double *q_direction, const double nac_factor,
+    const double (*dd_q0)[2], const double (*G_list)[3],
+    const int64_t num_G_points, const double lambda, const int64_t use_Wang_NAC,
+    const int64_t hermitianize) {
+    int64_t i, n, adrs_shift;
+    double *q_dir_cart;
+    double q_zero_tolerance;
+
+    q_zero_tolerance = 1e-5;
+    q_dir_cart = NULL;
+    adrs_shift = num_patom * num_patom * 9;
+
+    if (q_direction) {
+        q_dir_cart = (double *)malloc(sizeof(double) * 3);
+        get_q_cart(q_dir_cart, q_direction, reciprocal_lattice);
+    }
+
+    if (use_Wang_NAC) {
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+        for (i = 0; i < n_qpoints; i++) {
+            get_dynmat_wang(dynamical_matrices + adrs_shift * i, qpoints[i], fc,
+                            svecs, multi, num_patom, num_satom, masses, p2s_map,
+                            s2p_map, born, dielectric, reciprocal_lattice,
+                            q_direction, q_dir_cart, nac_factor,
+                            q_zero_tolerance, hermitianize);
+        }
+    } else {
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+        for (i = 0; i < n_qpoints; i++) {
+            get_dynamical_matrix_at_q(dynamical_matrices + adrs_shift * i,
+                                      num_patom, num_satom, fc, qpoints[i],
+                                      svecs, multi, masses, s2p_map, p2s_map,
+                                      NULL, hermitianize, 0);
+            if (dd_q0) {  // NAC by Gonze and Lee if dd_in is not NULL
+                add_dynmat_dd_at_q(dynamical_matrices + adrs_shift * i,
+                                   qpoints[i], fc, positions, num_patom, masses,
+                                   born, dielectric, reciprocal_lattice,
+                                   q_dir_cart, nac_factor, dd_q0, G_list,
+                                   num_G_points, lambda, q_zero_tolerance);
+            }
+        }
+    }
+
+    if (q_direction) {
+        free(q_dir_cart);
+        q_dir_cart = NULL;
+    }
+    return 0;
+}
+
+static void get_dynmat_wang(
+    double (*dynamical_matrices)[2], const double qpoint[3], const double *fc,
+    const double (*svecs)[3], const int64_t (*multi)[2],
+    const int64_t num_patom, const int64_t num_satom, const double *masses,
+    const int64_t *p2s_map, const int64_t *s2p_map, const double (*born)[3][3],
+    const double dielectric[3][3], const double (*reciprocal_lattice)[3],
+    const double *q_direction, const double *q_dir_cart,
+    const double nac_factor, const double q_zero_tolerance,
+    const int64_t hermitianize) {
+    double (*charge_sum)[3][3];
+    double q_cart[3];
+    double q_norm;
+    int64_t n;
+
+    charge_sum = NULL;
+    n = num_satom / num_patom;
+
+    get_q_cart(q_cart, qpoint, reciprocal_lattice);
+    q_norm = sqrt(q_cart[0] * q_cart[0] + q_cart[1] * q_cart[1] +
+                  q_cart[2] * q_cart[2]);
+    charge_sum =
+        (double (*)[3][3])malloc(sizeof(double[3][3]) * num_patom * num_patom);
+
+    if (q_norm < q_zero_tolerance) {
+        if (q_direction) {
+            dym_get_charge_sum(
+                charge_sum, num_patom,
+                nac_factor / n / get_dielectric_part(q_dir_cart, dielectric),
+                q_dir_cart, born);
+            get_dynamical_matrix_at_q(dynamical_matrices, num_patom, num_satom,
+                                      fc, qpoint, svecs, multi, masses, s2p_map,
+                                      p2s_map, charge_sum, hermitianize, 0);
+
+        } else {
+            get_dynamical_matrix_at_q(dynamical_matrices, num_patom, num_satom,
+                                      fc, qpoint, svecs, multi, masses, s2p_map,
+                                      p2s_map, NULL, hermitianize, 0);
+        }
+    } else {
+        dym_get_charge_sum(
+            charge_sum, num_patom,
+            nac_factor / n / get_dielectric_part(q_cart, dielectric), q_cart,
+            born);
+        get_dynamical_matrix_at_q(dynamical_matrices, num_patom, num_satom, fc,
+                                  qpoint, svecs, multi, masses, s2p_map,
+                                  p2s_map, charge_sum, hermitianize, 0);
+    }
+
+    free(charge_sum);
+    charge_sum = NULL;
+}
+
+static void add_dynmat_dd_at_q(
+    double (*dynamical_matrices)[2], const double q[3], const double *fc,
+    const double (*positions)[3], const int64_t num_patom, const double *masses,
+    const double (*born)[3][3], const double dielectric[3][3],
+    const double reciprocal_lattice[3][3], const double *q_dir_cart,
+    const double nac_factor, const double (*dd_q0)[2],
+    const double (*G_list)[3], const int64_t num_G_points, const double lambda,
+    const double tolerance) {
+    int64_t i, j, k, l, adrs;
+    double (*dd)[2];
+    double q_cart[3];
+    double mm;
+
+    dd = (double (*)[2])malloc(sizeof(double[2]) * num_patom * num_patom * 9);
+    get_q_cart(q_cart, q, reciprocal_lattice);
+    dym_get_recip_dipole_dipole(dd, dd_q0, G_list, num_G_points, num_patom,
+                                q_cart, q_dir_cart, born, dielectric, positions,
+                                nac_factor, lambda, tolerance, 0);
+
+    for (i = 0; i < num_patom; i++) {
+        for (j = 0; j < num_patom; j++) {
+            mm = sqrt(masses[i] * masses[j]);
+            for (k = 0; k < 3; k++) {
+                for (l = 0; l < 3; l++) {
+                    adrs = i * num_patom * 9 + k * num_patom * 3 + j * 3 + l;
+                    dynamical_matrices[adrs][0] += dd[adrs][0] / mm;
+                    dynamical_matrices[adrs][1] += dd[adrs][1] / mm;
+                }
+            }
+        }
+    }
+
+    free(dd);
+    dd = NULL;
+}
+
+void dym_get_recip_dipole_dipole(
+    double (*dd)[2],           /* [natom, 3, natom, 3, (real,imag)] */
+    const double (*dd_q0)[2],  /* [natom, 3, 3, (real,imag)] */
+    const double (*G_list)[3], /* [num_G, 3] */
+    const int64_t num_G, const int64_t num_patom, const double q_cart[3],
+    const double *q_direction_cart, /* must be pointer */
+    const double (*born)[3][3], const double dielectric[3][3],
+    const double (*pos)[3], /* [num_patom, 3] */
+    const double factor,    /* 4pi/V*unit-conv */
+    const double lambda, const double tolerance, const int64_t use_openmp) {
+    int64_t i, k, l, adrs, adrs_sum;
+    double (*dd_tmp)[2];
+
+    dd_tmp =
+        (double (*)[2])malloc(sizeof(double[2]) * num_patom * num_patom * 9);
+
+    for (i = 0; i < num_patom * num_patom * 9; i++) {
+        dd[i][0] = 0;
+        dd[i][1] = 0;
+        dd_tmp[i][0] = 0;
+        dd_tmp[i][1] = 0;
+    }
+
+    get_dd(dd_tmp, G_list, num_G, num_patom, q_cart, q_direction_cart,
+           dielectric, pos, lambda, tolerance, use_openmp);
+
+    multiply_borns(dd, dd_tmp, num_patom, born, use_openmp);
+
+    for (i = 0; i < num_patom; i++) {
+        for (k = 0; k < 3; k++) {     /* alpha */
+            for (l = 0; l < 3; l++) { /* beta */
+                adrs = i * num_patom * 9 + k * num_patom * 3 + i * 3 + l;
+                adrs_sum = i * 9 + k * 3 + l;
+                dd[adrs][0] -= dd_q0[adrs_sum][0];
+                dd[adrs][1] -= dd_q0[adrs_sum][1];
+            }
+        }
+    }
+
+    for (i = 0; i < num_patom * num_patom * 9; i++) {
+        dd[i][0] *= factor;
+        dd[i][1] *= factor;
+    }
+
+    /* This may not be necessary. */
+    /* make_Hermitian(dd, num_patom * 3); */
+
+    free(dd_tmp);
+    dd_tmp = NULL;
+}
+
+void dym_get_recip_dipole_dipole_q0(
+    double (*dd_q0)[2],        /* [natom, 3, 3, (real,imag)] */
+    const double (*G_list)[3], /* [num_G, 3] */
+    const int64_t num_G, const int64_t num_patom, const double (*born)[3][3],
+    const double dielectric[3][3], const double (*pos)[3], /* [num_patom, 3] */
+    const double lambda, const double tolerance, const int64_t use_openmp) {
+    int64_t i, j, k, l, adrs_tmp, adrs, adrsT;
+    double zero_vec[3];
+    double (*dd_tmp1)[2], (*dd_tmp2)[2];
+
+    dd_tmp1 =
+        (double (*)[2])malloc(sizeof(double[2]) * num_patom * num_patom * 9);
+    dd_tmp2 =
+        (double (*)[2])malloc(sizeof(double[2]) * num_patom * num_patom * 9);
+
+    for (i = 0; i < num_patom * num_patom * 9; i++) {
+        dd_tmp1[i][0] = 0;
+        dd_tmp1[i][1] = 0;
+        dd_tmp2[i][0] = 0;
+        dd_tmp2[i][1] = 0;
+    }
+
+    zero_vec[0] = 0;
+    zero_vec[1] = 0;
+    zero_vec[2] = 0;
+
+    get_dd(dd_tmp1, G_list, num_G, num_patom, zero_vec, NULL, dielectric, pos,
+           lambda, tolerance, use_openmp);
+
+    multiply_borns(dd_tmp2, dd_tmp1, num_patom, born, use_openmp);
+
+    for (i = 0; i < num_patom * 9; i++) {
+        dd_q0[i][0] = 0;
+        dd_q0[i][1] = 0;
+    }
+
+    for (i = 0; i < num_patom; i++) {
+        for (k = 0; k < 3; k++) {     /* alpha */
+            for (l = 0; l < 3; l++) { /* beta */
+                adrs = i * 9 + k * 3 + l;
+                for (j = 0; j < num_patom; j++) {
+                    adrs_tmp =
+                        i * num_patom * 9 + k * num_patom * 3 + j * 3 + l;
+                    dd_q0[adrs][0] += dd_tmp2[adrs_tmp][0];
+                    dd_q0[adrs][1] += dd_tmp2[adrs_tmp][1];
+                }
+            }
+        }
+    }
+
+    /* Summation over another atomic index */
+    /* for (j = 0; j < num_patom; j++) { */
+    /*   for (k = 0; k < 3; k++) {   /\* alpha *\/ */
+    /*     for (l = 0; l < 3; l++) { /\* beta *\/ */
+    /*       adrs = j * 9 + k * 3 + l; */
+    /*       for (i = 0; i < num_patom; i++) { */
+    /*         adrs_tmp = i * num_patom * 9 + k * num_patom * 3 + j * 3 + l
+     * ; */
+    /*         dd_q0[adrs][0] += dd_tmp2[adrs_tmp][0]; */
+    /*         dd_q0[adrs][1] += dd_tmp2[adrs_tmp][1]; */
+    /*       } */
+    /*     } */
+    /*   } */
+    /* } */
+
+    for (i = 0; i < num_patom; i++) {
+        for (k = 0; k < 3; k++) {     /* alpha */
+            for (l = 0; l < 3; l++) { /* beta */
+                adrs = i * 9 + k * 3 + l;
+                adrsT = i * 9 + l * 3 + k;
+                dd_q0[adrs][0] += dd_q0[adrsT][0];
+                dd_q0[adrs][0] /= 2;
+                dd_q0[adrsT][0] = dd_q0[adrs][0];
+                dd_q0[adrs][1] -= dd_q0[adrsT][1];
+                dd_q0[adrs][1] /= 2;
+                dd_q0[adrsT][1] = -dd_q0[adrs][1];
+            }
+        }
+    }
+
+    free(dd_tmp1);
+    dd_tmp1 = NULL;
+    free(dd_tmp2);
+    dd_tmp2 = NULL;
+}
+
+void dym_get_charge_sum(
+    double (*charge_sum)[3][3], const int64_t num_patom,
+    const double factor, /* 4pi/V*unit-conv and denominator */
+    const double q_cart[3], const double (*born)[3][3]) {
+    int64_t i, j, k, a, b;
+    double (*q_born)[3];
+
+    q_born = (double (*)[3])malloc(sizeof(double[3]) * num_patom);
+    for (i = 0; i < num_patom; i++) {
+        for (j = 0; j < 3; j++) {
+            q_born[i][j] = 0;
+        }
+    }
+
+    for (i = 0; i < num_patom; i++) {
+        for (j = 0; j < 3; j++) {
+            for (k = 0; k < 3; k++) {
+                q_born[i][j] += q_cart[k] * born[i][k][j];
+            }
+        }
+    }
+
+    for (i = 0; i < num_patom; i++) {
+        for (j = 0; j < num_patom; j++) {
+            for (a = 0; a < 3; a++) {
+                for (b = 0; b < 3; b++) {
+                    charge_sum[i * num_patom + j][a][b] =
+                        q_born[i][a] * q_born[j][b] * factor;
+                }
+            }
+        }
+    }
+
+    free(q_born);
+    q_born = NULL;
+}
+
+/* fc[num_patom, num_satom, 3, 3] */
+/* dm[num_comm_points, num_patom * 3, num_patom *3] */
+/* comm_points[num_satom / num_patom, 3] */
+/* shortest_vectors[:, 3] */
+/* multiplicities[num_satom, num_patom, 2] */
+void dym_transform_dynmat_to_fc(
+    double *fc, const double (*dm)[2], const double (*comm_points)[3],
+    const double (*svecs)[3], const int64_t (*multi)[2], const double *masses,
+    const int64_t *s2pp_map, const int64_t *fc_index_map,
+    const int64_t num_patom, const int64_t num_satom,
+    const int64_t use_openmp) {
+    int64_t i, j, ij;
+
+    for (i = 0; i < num_patom * num_satom * 9; i++) {
+        fc[i] = 0;
+    }
+
+    if (use_openmp) {
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+        for (ij = 0; ij < num_patom * num_satom; ij++) {
+            transform_dynmat_to_fc_ij(
+                fc, dm, ij / num_satom, ij % num_satom, comm_points, svecs,
+                multi, masses, s2pp_map, fc_index_map, num_patom, num_satom);
+        }
+    } else {
+        for (i = 0; i < num_patom; i++) {
+            for (j = 0; j < num_satom; j++) {
+                transform_dynmat_to_fc_ij(fc, dm, i, j, comm_points, svecs,
+                                          multi, masses, s2pp_map, fc_index_map,
+                                          num_patom, num_satom);
+            }
+        }
+    }
+}
+
+/// @brief charge_sum is NULL if G-L NAC or no-NAC.
+static int64_t get_dynamical_matrix_at_q(
+    double (*dynamical_matrix)[2], const int64_t num_patom,
+    const int64_t num_satom, const double *fc, const double q[3],
+    const double (*svecs)[3], const int64_t (*multi)[2], const double *mass,
+    const int64_t *s2p_map, const int64_t *p2s_map,
+    const double (*charge_sum)[3][3], const int64_t hermitianize,
+    const int64_t use_openmp) {
+    int64_t i, j, ij;
+
+    if (use_openmp) {
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+        for (ij = 0; ij < num_patom * num_patom; ij++) {
+            get_dynmat_ij(dynamical_matrix, num_patom, num_satom, fc, q, svecs,
+                          multi, mass, s2p_map, p2s_map, charge_sum,
+                          ij / num_patom,  /* i */
+                          ij % num_patom); /* j */
+        }
+    } else {
+        for (i = 0; i < num_patom; i++) {
+            for (j = 0; j < num_patom; j++) {
+                get_dynmat_ij(dynamical_matrix, num_patom, num_satom, fc, q,
+                              svecs, multi, mass, s2p_map, p2s_map, charge_sum,
+                              i, j);
+            }
+        }
+    }
+
+    if (hermitianize) {
+        make_Hermitian(dynamical_matrix, num_patom * 3);
+    }
+
+    return 0;
+}
+
+/// @brief charge_sum is NULL if G-L NAC or no-NAC.
+static void get_dynmat_ij(double (*dynamical_matrix)[2],
+                          const int64_t num_patom, const int64_t num_satom,
+                          const double *fc, const double q[3],
+                          const double (*svecs)[3], const int64_t (*multi)[2],
+                          const double *mass, const int64_t *s2p_map,
+                          const int64_t *p2s_map,
+                          const double (*charge_sum)[3][3], const int64_t i,
+                          const int64_t j) {
+    int64_t k, l, adrs;
+    double mass_sqrt;
+    double dm[3][3][2];  // [3][3][(real, imag)]
+
+    mass_sqrt = sqrt(mass[i] * mass[j]);
+
+    for (k = 0; k < 3; k++) {
+        for (l = 0; l < 3; l++) {
+            dm[k][l][0] = 0;
+            dm[k][l][1] = 0;
+        }
+    }
+
+    for (k = 0; k < num_satom; k++) { /* Lattice points of right index of fc */
+        if (s2p_map[k] != p2s_map[j]) {
+            continue;
+        }
+        get_dm(dm, num_patom, num_satom, fc, q, svecs, multi, p2s_map,
+               charge_sum, i, j, k);
+    }
+
+    for (k = 0; k < 3; k++) {
+        for (l = 0; l < 3; l++) {
+            adrs = (i * 3 + k) * num_patom * 3 + j * 3 + l;
+            dynamical_matrix[adrs][0] = dm[k][l][0] / mass_sqrt;
+            dynamical_matrix[adrs][1] = dm[k][l][1] / mass_sqrt;
+        }
+    }
+}
+
+static void get_dm(double dm[3][3][2], const int64_t num_patom,
+                   const int64_t num_satom, const double *fc, const double q[3],
+                   const double (*svecs)[3], const int64_t (*multi)[2],
+                   const int64_t *p2s_map, const double (*charge_sum)[3][3],
+                   const int64_t i, const int64_t j, const int64_t k) {
+    int64_t l, m, i_pair, m_pair, adrs;
+    double phase, cos_phase, sin_phase, fc_elem;
+
+    cos_phase = 0;
+    sin_phase = 0;
+
+    i_pair = k * num_patom + i;
+    m_pair = multi[i_pair][0];
+    adrs = multi[i_pair][1];
+
+    for (l = 0; l < m_pair; l++) {
+        phase = 0;
+        for (m = 0; m < 3; m++) {
+            phase += q[m] * svecs[adrs + l][m];
+        }
+        cos_phase += cos(phase * 2 * PI) / m_pair;
+        sin_phase += sin(phase * 2 * PI) / m_pair;
+    }
+
+    for (l = 0; l < 3; l++) {
+        for (m = 0; m < 3; m++) {
+            if (charge_sum) {
+                fc_elem = (fc[p2s_map[i] * num_satom * 9 + k * 9 + l * 3 + m] +
+                           charge_sum[i * num_patom + j][l][m]);
+            } else {
+                fc_elem = fc[p2s_map[i] * num_satom * 9 + k * 9 + l * 3 + m];
+            }
+            dm[l][m][0] += fc_elem * cos_phase;
+            dm[l][m][1] += fc_elem * sin_phase;
+        }
+    }
+}
+
+static double get_dielectric_part(const double q_cart[3],
+                                  const double dielectric[3][3]) {
+    int64_t i, j;
+    double sum;
+
+    sum = 0;
+    for (i = 0; i < 3; i++) {
+        for (j = 0; j < 3; j++) {
+            sum += q_cart[i] * dielectric[i][j] * q_cart[j];
+        }
+    }
+    return sum;
+}
+
+static void get_dd(double (*dd_part)[2], /* [natom, 3, natom, 3, (real,imag)] */
+                   const double (*G_list)[3], /* [num_G, 3] */
+                   const int64_t num_G, const int64_t num_patom,
+                   const double q_cart[3], const double *q_direction_cart,
+                   const double dielectric[3][3],
+                   const double (*pos)[3], /* [num_patom, 3] */
+                   const double lambda, const double tolerance,
+                   const int64_t use_openmp) {
+    int64_t i, j, g;
+    double q_K[3];
+    double norm, dielectric_part, L2;
+    double (*KK)[3][3];
+
+    KK = (double (*)[3][3])malloc(sizeof(double[3][3]) * num_G);
+    L2 = 4 * lambda * lambda;
+
+    /* sum over K = G + q and over G (i.e. q=0) */
+    /* q_direction has values for summation over K at Gamma point. */
+    /* q_direction is NULL for summation over G */
+#ifdef _OPENMP
+#pragma omp parallel for private(i, j, q_K, norm, \
+                                     dielectric_part) if (use_openmp)
+#endif
+    for (g = 0; g < num_G; g++) {
+        norm = 0;
+        for (i = 0; i < 3; i++) {
+            q_K[i] = G_list[g][i] + q_cart[i];
+            norm += q_K[i] * q_K[i];
+        }
+
+        if (sqrt(norm) < tolerance) {
+            if (!q_direction_cart) {
+                for (i = 0; i < 3; i++) {
+                    for (j = 0; j < 3; j++) {
+                        KK[g][i][j] = 0;
+                    }
+                }
+                continue;
+            } else {
+                dielectric_part =
+                    get_dielectric_part(q_direction_cart, dielectric);
+                for (i = 0; i < 3; i++) {
+                    for (j = 0; j < 3; j++) {
+                        KK[g][i][j] = q_direction_cart[i] *
+                                      q_direction_cart[j] / dielectric_part;
+                    }
+                }
+            }
+        } else {
+            dielectric_part = get_dielectric_part(q_K, dielectric);
+            for (i = 0; i < 3; i++) {
+                for (j = 0; j < 3; j++) {
+                    KK[g][i][j] = q_K[i] * q_K[j] / dielectric_part *
+                                  exp(-dielectric_part / L2);
+                }
+            }
+        }
+    }
+
+    // OpenMP should not be used here.
+    // Due to race condition in dd_part and bad performance.
+    for (g = 0; g < num_G; g++) {
+        for (i = 0; i < num_patom; i++) {
+            for (j = 0; j < num_patom; j++) {
+                get_dd_at_g(dd_part, i, j, G_list[g], num_patom, pos, KK[g]);
+            }
+        }
+    }
+
+    free(KK);
+    KK = NULL;
+}
+
+static void get_dd_at_g(
+    double (*dd_part)[2], /* [natom, 3, natom, 3, (real,imag)] */
+    const int64_t i, const int64_t j, const double G[3],
+    const int64_t num_patom, const double (*pos)[3], /* [num_patom, 3] */
+    const double KK[3][3]) {
+    int64_t k, l, adrs;
+    double cos_phase, sin_phase, phase;
+
+    phase = 0;
+    for (k = 0; k < 3; k++) {
+        /* For D-type dynamical matrix */
+        /* phase += (pos[i][k] - pos[j][k]) * q_K[k]; */
+        /* For C-type dynamical matrix */
+        phase += (pos[i][k] - pos[j][k]) * G[k];
+    }
+    phase *= 2 * PI;
+    cos_phase = cos(phase);
+    sin_phase = sin(phase);
+    for (k = 0; k < 3; k++) {
+        for (l = 0; l < 3; l++) {
+            adrs = i * num_patom * 9 + k * num_patom * 3 + j * 3 + l;
+            dd_part[adrs][0] += KK[k][l] * cos_phase;
+            dd_part[adrs][1] += KK[k][l] * sin_phase;
+        }
+    }
+}
+
+static void make_Hermitian(double (*mat)[2], const int64_t num_band) {
+    int64_t i, j, adrs, adrsT;
+
+    for (i = 0; i < num_band; i++) {
+        for (j = i; j < num_band; j++) {
+            adrs = i * num_band + j;
+            adrsT = j * num_band + i;
+            /* real part */
+            mat[adrs][0] += mat[adrsT][0];
+            mat[adrs][0] /= 2;
+            /* imaginary part */
+            mat[adrs][1] -= mat[adrsT][1];
+            mat[adrs][1] /= 2;
+            /* store */
+            mat[adrsT][0] = mat[adrs][0];
+            mat[adrsT][1] = -mat[adrs][1];
+        }
+    }
+}
+
+static void multiply_borns(double (*dd)[2], const double (*dd_in)[2],
+                           const int64_t num_patom, const double (*born)[3][3],
+                           const int64_t use_openmp) {
+    int64_t i, j, ij;
+
+    if (use_openmp) {
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+        for (ij = 0; ij < num_patom * num_patom; ij++) {
+            multiply_borns_at_ij(dd, ij / num_patom, ij % num_patom, dd_in,
+                                 num_patom, born);
+        }
+    } else {
+        for (i = 0; i < num_patom; i++) {
+            for (j = 0; j < num_patom; j++) {
+                multiply_borns_at_ij(dd, i, j, dd_in, num_patom, born);
+            }
+        }
+    }
+}
+
+static void multiply_borns_at_ij(double (*dd)[2], const int64_t i,
+                                 const int64_t j, const double (*dd_in)[2],
+                                 const int64_t num_patom,
+                                 const double (*born)[3][3]) {
+    int64_t k, l, m, n, adrs, adrs_in;
+    double zz;
+
+    for (k = 0; k < 3; k++) {     /* alpha */
+        for (l = 0; l < 3; l++) { /* beta */
+            adrs = i * num_patom * 9 + k * num_patom * 3 + j * 3 + l;
+            for (m = 0; m < 3; m++) {     /* alpha' */
+                for (n = 0; n < 3; n++) { /* beta' */
+                    adrs_in = i * num_patom * 9 + m * num_patom * 3 + j * 3 + n;
+                    zz = born[i][m][k] * born[j][n][l];
+                    dd[adrs][0] += dd_in[adrs_in][0] * zz;
+                    dd[adrs][1] += dd_in[adrs_in][1] * zz;
+                }
+            }
+        }
+    }
+}
+
+static void transform_dynmat_to_fc_ij(
+    double *fc, const double (*dm)[2], const int64_t i, const int64_t j,
+    const double (*comm_points)[3], const double (*svecs)[3],
+    const int64_t (*multi)[2], const double *masses, const int64_t *s2pp_map,
+    const int64_t *fc_index_map, const int64_t num_patom,
+    const int64_t num_satom) {
+    int64_t k, l, m, N, adrs, m_pair, i_pair, svecs_adrs;
+    double coef, phase, cos_phase, sin_phase;
+
+    N = num_satom / num_patom;
+    i_pair = j * num_patom + i;
+    m_pair = multi[i_pair][0];
+    svecs_adrs = multi[i_pair][1];
+    coef = sqrt(masses[i] * masses[s2pp_map[j]]) / N;
+    for (k = 0; k < N; k++) {
+        cos_phase = 0;
+        sin_phase = 0;
+        for (l = 0; l < m_pair; l++) {
+            phase = 0;
+            for (m = 0; m < 3; m++) {
+                phase -= comm_points[k][m] * svecs[svecs_adrs + l][m];
+            }
+            cos_phase += cos(phase * 2 * PI);
+            sin_phase += sin(phase * 2 * PI);
+        }
+        cos_phase /= m_pair;
+        sin_phase /= m_pair;
+        for (l = 0; l < 3; l++) {
+            for (m = 0; m < 3; m++) {
+                adrs = k * num_patom * num_patom * 9 + i * num_patom * 9 +
+                       l * num_patom * 3 + s2pp_map[j] * 3 + m;
+                fc[fc_index_map[i] * num_satom * 9 + j * 9 + l * 3 + m] +=
+                    (dm[adrs][0] * cos_phase - dm[adrs][1] * sin_phase) * coef;
+            }
+        }
+    }
+}
+
+/// @brief
+/// @param q_cart q-point in Cartesian coordinates
+/// @param q q-point in crystallographic coordinates
+/// @param reciprocal_lattice in column vectors
+static void get_q_cart(double q_cart[3], const double q[3],
+                       const double reciprocal_lattice[3][3]) {
+    int64_t i, j;
+
+    for (i = 0; i < 3; i++) {
+        q_cart[i] = 0;
+        for (j = 0; j < 3; j++) {
+            q_cart[i] += reciprocal_lattice[i][j] * q[j];
+        }
+    }
+}

phonopy/source/c/dynmat.h

@@ -0,0 +1,81 @@
+/* Copyright (C) 2015 Atsushi Togo */
+/* All rights reserved. */
+
+/* This file is part of phonopy. */
+
+/* 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 __dynmat_H__
+#define __dynmat_H__
+
+#include <stdint.h>
+
+int64_t dym_dynamical_matrices_with_dd_openmp_over_qpoints(
+    double (*dynamical_matrices)[2], const double (*qpoints)[3],
+    const int64_t n_qpoints, const double *fc, const double (*svecs)[3],
+    const int64_t (*multi)[2], const double (*positions)[3],
+    const int64_t num_patom, const int64_t num_satom, const double *masses,
+    const int64_t *p2s_map, const int64_t *s2p_map, const double (*born)[3][3],
+    const double dielectric[3][3], const double (*reciprocal_lattice)[3],
+    const double *q_direction, const double nac_factor,
+    const double (*dd_q0)[2], const double (*G_list)[3],
+    const int64_t num_G_points, const double lambda, const int64_t use_Wang_NAC,
+    const int64_t hermitianize);
+void dym_get_recip_dipole_dipole(
+    double (*dd)[2],           /* [natom, 3, natom, 3, (real,imag)] */
+    const double (*dd_q0)[2],  /* [natom, 3, 3, (real,imag)] */
+    const double (*G_list)[3], /* [num_G, 3] */
+    const int64_t num_G, const int64_t num_patom, const double q_cart[3],
+    const double *q_direction_cart, /* must be pointer */
+    const double (*born)[3][3], const double dielectric[3][3],
+    const double (*pos)[3], /* [num_patom, 3] */
+    const double factor,    /* 4pi/V*unit-conv */
+    const double lambda, const double tolerance, const int64_t use_openmp);
+void dym_get_recip_dipole_dipole_q0(
+    double (*dd_q0)[2],        /* [natom, 3, 3, (real,imag)] */
+    const double (*G_list)[3], /* [num_G, 3] */
+    const int64_t num_G, const int64_t num_patom, const double (*born)[3][3],
+    const double dielectric[3][3], const double (*pos)[3], /* [natom, 3] */
+    const double lambda, const double tolerance, const int64_t use_openmp);
+void dym_get_charge_sum(double (*charge_sum)[3][3], const int64_t num_patom,
+                        const double factor, const double q_cart[3],
+                        const double (*born)[3][3]);
+/* fc[num_patom, num_satom, 3, 3] */
+/* dm[num_comm_points, num_patom * 3, num_patom *3] */
+/* comm_points[num_satom / num_patom, 3] */
+/* shortest_vectors[:, 3] */
+/* multiplicities[num_satom, num_patom, 2] */
+void dym_transform_dynmat_to_fc(
+    double *fc, const double (*dm)[2], const double (*comm_points)[3],
+    const double (*svecs)[3], const int64_t (*multi)[2], const double *masses,
+    const int64_t *s2pp_map, const int64_t *fc_index_map,
+    const int64_t num_patom, const int64_t num_satom, const int64_t use_openmp);
+
+#endif

phonopy/source/c/phonopy.c

@@ -0,0 +1,899 @@
+/* Copyright (C) 2021 Atsushi Togo */
+/* All rights reserved. */
+
+/* This file is part of phonopy. */
+
+/* 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. */
+
+#include "phonopy.h"
+
+#include <float.h>
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "derivative_dynmat.h"
+#include "dynmat.h"
+#include "rgrid.h"
+#include "tetrahedron_method.h"
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+static void set_index_permutation_symmetry_fc(double *fc, const int natom);
+static void set_translational_symmetry_fc(double *fc, const int natom);
+static void set_translational_symmetry_compact_fc(double *fc, const int p2s[],
+                                                  const int n_satom,
+                                                  const int n_patom);
+static double get_free_energy(const double temperature, const double f,
+                              const double KB, const int classical);
+static double get_entropy(const double temperature, const double f,
+                          const double KB, const int classical);
+static double get_heat_capacity(const double temperature, const double f,
+                                const double KB, const int classical);
+/* static double get_energy(double temperature, double f); */
+static void distribute_fc2(double (*fc2)[3][3], const int *atom_list,
+                           const int len_atom_list,
+                           const int *fc_indices_of_atom_list,
+                           const double (*r_carts)[3][3],
+                           const int *permutations, const int *map_atoms,
+                           const int *map_syms, const int num_rot,
+                           const int num_pos);
+static int nint(const double a);
+
+void phpy_transform_dynmat_to_fc(
+    double *fc, const double (*dm)[2], const double (*comm_points)[3],
+    const double (*svecs)[3], const int64_t (*multi)[2], const double *masses,
+    const int64_t *s2pp_map, const int64_t *fc_index_map,
+    const int64_t num_patom, const int64_t num_satom,
+    const int64_t use_openmp) {
+    dym_transform_dynmat_to_fc(fc, dm, comm_points, svecs, multi, masses,
+                               s2pp_map, fc_index_map, num_patom, num_satom,
+                               use_openmp);
+}
+
+int64_t phpy_dynamical_matrices_with_dd_openmp_over_qpoints(
+    double (*dynamical_matrices)[2], const double (*qpoints)[3],
+    const int64_t n_qpoints, const double *fc, const double (*svecs)[3],
+    const int64_t (*multi)[2], const double (*positions)[3],
+    const int64_t num_patom, const int64_t num_satom, const double *masses,
+    const int64_t *p2s_map, const int64_t *s2p_map, const double (*born)[3][3],
+    const double dielectric[3][3], const double (*reciprocal_lattice)[3],
+    const double *q_direction, const double nac_factor,
+    const double (*dd_q0)[2], const double (*G_list)[3],
+    const int64_t num_G_points, const double lambda, const int64_t use_Wang_NAC,
+    const int64_t hermitianize) {
+    return dym_dynamical_matrices_with_dd_openmp_over_qpoints(
+        dynamical_matrices, qpoints, n_qpoints, fc, svecs, multi, positions,
+        num_patom, num_satom, masses, p2s_map, s2p_map, born, dielectric,
+        reciprocal_lattice, q_direction, nac_factor, dd_q0, G_list,
+        num_G_points, lambda, use_Wang_NAC, hermitianize);
+}
+
+void phpy_get_charge_sum(
+    double (*charge_sum)[3][3], const int64_t num_patom,
+    const double factor, /* 4pi/V*unit-conv and denominator */
+    const double q_cart[3], const double (*born)[3][3]) {
+    dym_get_charge_sum(charge_sum, num_patom, factor, q_cart, born);
+}
+
+void phpy_get_recip_dipole_dipole(
+    double (*dd)[2],           /* [natom, 3, natom, 3, (real,imag)] */
+    const double (*dd_q0)[2],  /* [natom, 3, 3, (real,imag)] */
+    const double (*G_list)[3], /* [num_G, 3] */
+    const int64_t num_G, const int64_t num_patom, const double q_cart[3],
+    const double *q_direction_cart, /* must be pointer */
+    const double (*born)[3][3], const double dielectric[3][3],
+    const double (*pos)[3], /* [num_patom, 3] */
+    const double factor,    /* 4pi/V*unit-conv */
+    const double lambda, const double tolerance, const int64_t use_openmp) {
+    dym_get_recip_dipole_dipole(dd, dd_q0, G_list, num_G, num_patom, q_cart,
+                                q_direction_cart, born, dielectric, pos, factor,
+                                lambda, tolerance, use_openmp);
+}
+
+void phpy_get_recip_dipole_dipole_q0(
+    double (*dd_q0)[2],        /* [natom, 3, 3, (real,imag)] */
+    const double (*G_list)[3], /* [num_G, 3] */
+    const int64_t num_G, const int64_t num_patom, const double (*born)[3][3],
+    const double dielectric[3][3], const double (*pos)[3], /* [num_patom, 3] */
+    const double lambda, const double tolerance, const int64_t use_openmp) {
+    dym_get_recip_dipole_dipole_q0(dd_q0, G_list, num_G, num_patom, born,
+                                   dielectric, pos, lambda, tolerance,
+                                   use_openmp);
+}
+
+void phpy_get_derivative_dynmat_at_q(
+    double (*derivative_dynmat)[2], const int64_t num_patom,
+    const int64_t num_satom, const double *fc, const double *q,
+    const double *lattice, /* column vector */
+    const double *reclat,  /* column vector */
+    const double (*svecs)[3], const int64_t (*multi)[2], const double *mass,
+    const int64_t *s2p_map, const int64_t *p2s_map, const double nac_factor,
+    const double *born, const double *dielectric, const double *q_direction,
+    const int64_t is_nac, const int64_t use_openmp) {
+    ddm_get_derivative_dynmat_at_q(derivative_dynmat, num_patom, num_satom, fc,
+                                   q, lattice, reclat, svecs, multi, mass,
+                                   s2p_map, p2s_map, nac_factor, born,
+                                   dielectric, q_direction, is_nac, use_openmp);
+}
+
+void phpy_get_relative_grid_address(int64_t relative_grid_address[24][4][3],
+                                    const double reciprocal_lattice[3][3]) {
+    thm_get_relative_grid_address(relative_grid_address, reciprocal_lattice);
+}
+
+void phpy_get_all_relative_grid_address(
+    int64_t relative_grid_address[4][24][4][3]) {
+    thm_get_all_relative_grid_address(relative_grid_address);
+}
+
+double phpy_get_integration_weight(const double omega,
+                                   const double tetrahedra_omegas[24][4],
+                                   const char function) {
+    return thm_get_integration_weight(omega, tetrahedra_omegas, function);
+}
+
+void phpy_get_tetrahedra_frequenies(
+    double *freq_tetras, const int64_t mesh[3], const int64_t *grid_points,
+    const int64_t (*grid_address)[3], const int64_t (*relative_grid_address)[3],
+    const int64_t *gp_ir_index, const double *frequencies,
+    const int64_t num_band, const int64_t num_gp) {
+    int64_t is_shift[3] = {0, 0, 0};
+    int64_t i, j, k, gp;
+    int64_t g_addr[3];
+    int64_t address_double[3];
+
+    /* relative_grid_address[4, 24, 3] is viewed as [96, 3]. */
+    for (i = 0; i < num_gp; i++) {
+#ifdef _OPENMP
+#pragma omp parallel for private(k, g_addr, gp, address_double)
+#endif
+        for (j = 0; j < num_band * 96; j++) {
+            for (k = 0; k < 3; k++) {
+                g_addr[k] = grid_address[grid_points[i]][k] +
+                            relative_grid_address[j % 96][k];
+            }
+            rgd_get_double_grid_address(address_double, g_addr, mesh, is_shift);
+            gp = rgd_get_double_grid_index(address_double, mesh);
+            freq_tetras[i * num_band * 96 + j] =
+                frequencies[gp_ir_index[gp] * num_band + j / 96];
+        }
+    }
+}
+
+void phpy_tetrahedron_method_dos(
+    double *dos, const int64_t mesh[3], const int64_t (*grid_address)[3],
+    const int64_t (*relative_grid_address)[4][3],
+    const int64_t *grid_mapping_table, const double *freq_points,
+    const double *frequencies, const double *coef,
+    const int64_t num_freq_points, const int64_t num_ir_gp,
+    const int64_t num_band, const int64_t num_coef, const int64_t num_gp) {
+    int64_t is_shift[3] = {0, 0, 0};
+    int64_t i, j, k, l, m, q, r, count;
+    int64_t ir_gps[24][4];
+    int64_t g_addr[3];
+    double tetrahedra[24][4];
+    int64_t address_double[3];
+    int64_t *gp2ir, *ir_grid_points;
+    int64_t *weights;
+    double iw;
+
+    gp2ir = NULL;
+    ir_grid_points = NULL;
+    weights = NULL;
+
+    gp2ir = (int64_t *)malloc(sizeof(int64_t) * num_gp);
+    ir_grid_points = (int64_t *)malloc(sizeof(int64_t) * num_ir_gp);
+    weights = (int64_t *)malloc(sizeof(int64_t) * num_ir_gp);
+
+    count = 0;
+    for (i = 0; i < num_gp; i++) {
+        if (grid_mapping_table[i] == i) {
+            gp2ir[i] = count;
+            ir_grid_points[count] = i;
+            weights[count] = 1;
+            count++;
+        } else {
+            gp2ir[i] = gp2ir[grid_mapping_table[i]];
+            weights[gp2ir[i]]++;
+        }
+    }
+
+    if (num_ir_gp != count) {
+        printf("Something is wrong!\n");
+    }
+
+#ifdef _OPENMP
+#pragma omp parallel for private(j, k, l, m, q, r, iw, ir_gps, g_addr, \
+                                     tetrahedra, address_double)
+#endif
+    for (i = 0; i < num_ir_gp; i++) {
+        /* set 24 tetrahedra */
+        for (l = 0; l < 24; l++) {
+            for (q = 0; q < 4; q++) {
+                for (r = 0; r < 3; r++) {
+                    g_addr[r] = grid_address[ir_grid_points[i]][r] +
+                                relative_grid_address[l][q][r];
+                }
+                rgd_get_double_grid_address(address_double, g_addr, mesh,
+                                            is_shift);
+                ir_gps[l][q] =
+                    gp2ir[rgd_get_double_grid_index(address_double, mesh)];
+            }
+        }
+
+        for (k = 0; k < num_band; k++) {
+            for (l = 0; l < 24; l++) {
+                for (q = 0; q < 4; q++) {
+                    tetrahedra[l][q] = frequencies[ir_gps[l][q] * num_band + k];
+                }
+            }
+            for (j = 0; j < num_freq_points; j++) {
+                iw = thm_get_integration_weight(freq_points[j], tetrahedra,
+                                                'I') *
+                     weights[i];
+                for (m = 0; m < num_coef; m++) {
+                    dos[i * num_band * num_freq_points * num_coef +
+                        k * num_coef * num_freq_points + j * num_coef + m] +=
+                        iw * coef[i * num_coef * num_band + m * num_band + k];
+                }
+            }
+        }
+    }
+
+    free(gp2ir);
+    gp2ir = NULL;
+    free(ir_grid_points);
+    ir_grid_points = NULL;
+    free(weights);
+    weights = NULL;
+}
+
+void phpy_get_thermal_properties(
+    double *thermal_props, const double *temperatures, const double *freqs,
+    const int64_t *weights, const int64_t num_temp, const int64_t num_qpoints,
+    const int64_t num_bands, const double cutoff_frequency, const double KB,
+    const int classical) {
+    int64_t i, j, k;
+    double f;
+    double *tp;
+
+    tp = (double *)malloc(sizeof(double) * num_qpoints * num_temp * 3);
+    for (i = 0; i < num_qpoints * num_temp * 3; i++) {
+        tp[i] = 0;
+    }
+
+#ifdef _OPENMP
+#pragma omp parallel for private(j, k, f)
+#endif
+    for (i = 0; i < num_qpoints; i++) {
+        for (j = 0; j < num_temp; j++) {
+            for (k = 0; k < num_bands; k++) {
+                f = freqs[i * num_bands + k];
+                if (temperatures[j] > 0 && f > cutoff_frequency) {
+                    tp[i * num_temp * 3 + j * 3] +=
+                        get_free_energy(temperatures[j], f, KB, classical) *
+                        weights[i];
+                    tp[i * num_temp * 3 + j * 3 + 1] +=
+                        get_entropy(temperatures[j], f, KB, classical) *
+                        weights[i];
+                    tp[i * num_temp * 3 + j * 3 + 2] +=
+                        get_heat_capacity(temperatures[j], f, KB, classical) *
+                        weights[i];
+                }
+            }
+        }
+    }
+
+    for (i = 0; i < num_qpoints; i++) {
+        for (j = 0; j < num_temp * 3; j++) {
+            thermal_props[j] += tp[i * num_temp * 3 + j];
+        }
+    }
+
+    free(tp);
+    tp = NULL;
+}
+
+void phpy_distribute_fc2(double (*fc2)[3][3], const int *atom_list,
+                         const int len_atom_list,
+                         const int *fc_indices_of_atom_list,
+                         const double (*r_carts)[3][3], const int *permutations,
+                         const int *map_atoms, const int *map_syms,
+                         const int num_rot, const int num_pos) {
+    distribute_fc2(fc2, atom_list, len_atom_list, fc_indices_of_atom_list,
+                   r_carts, permutations, map_atoms, map_syms, num_rot,
+                   num_pos);
+}
+
+int phpy_compute_permutation(int *rot_atom, const double lat[3][3],
+                             const double (*pos)[3], const double (*rot_pos)[3],
+                             const int num_pos, const double symprec) {
+    int i, j, k, l;
+    int search_start;
+    double distance2, diff_cart;
+    double diff[3];
+
+    for (i = 0; i < num_pos; i++) {
+        rot_atom[i] = -1;
+    }
+
+    /* optimization: Iterate primarily by pos instead of rot_pos. */
+    /*  (find where 0 beint64_ts in rot_atom, then where 1 beint64_ts, etc.) */
+    /*  Then track the first unassigned index. */
+    /* */
+    /* This works best if the permutation is close to the identity. */
+    /* (more specifically, if the max value of 'rot_atom[i] - i' is small)
+     */
+    search_start = 0;
+    for (i = 0; i < num_pos; i++) {
+        while (rot_atom[search_start] >= 0) {
+            search_start++;
+        }
+        for (j = search_start; j < num_pos; j++) {
+            if (rot_atom[j] >= 0) {
+                continue;
+            }
+
+            for (k = 0; k < 3; k++) {
+                diff[k] = pos[i][k] - rot_pos[j][k];
+                diff[k] -= nint(diff[k]);
+            }
+            distance2 = 0;
+            for (k = 0; k < 3; k++) {
+                diff_cart = 0;
+                for (l = 0; l < 3; l++) {
+                    diff_cart += lat[k][l] * diff[l];
+                }
+                distance2 += diff_cart * diff_cart;
+            }
+
+            if (sqrt(distance2) < symprec) {
+                rot_atom[j] = i;
+                break;
+            }
+        }
+    }
+
+    for (i = 0; i < num_pos; i++) {
+        if (rot_atom[i] < 0) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+void phpy_set_smallest_vectors_sparse(
+    double (*smallest_vectors)[27][3], int *multiplicity,
+    const double (*pos_to)[3], const int num_pos_to,
+    const double (*pos_from)[3], const int num_pos_from,
+    const int (*lattice_points)[3], const int num_lattice_points,
+    const double reduced_basis[3][3], const int trans_mat[3][3],
+    const double symprec) {
+    int i, j, k, l, count;
+    double length_tmp, minimum, vec_xyz;
+    double *length;
+    double (*vec)[3];
+
+    length = (double *)malloc(sizeof(double) * num_lattice_points);
+    vec = (double (*)[3])malloc(sizeof(double[3]) * num_lattice_points);
+
+    for (i = 0; i < num_pos_to; i++) {
+        for (j = 0; j < num_pos_from; j++) {
+            for (k = 0; k < num_lattice_points; k++) {
+                length[k] = 0;
+                for (l = 0; l < 3; l++) {
+                    vec[k][l] =
+                        pos_to[i][l] - pos_from[j][l] + lattice_points[k][l];
+                }
+                for (l = 0; l < 3; l++) {
+                    length_tmp = (reduced_basis[l][0] * vec[k][0] +
+                                  reduced_basis[l][1] * vec[k][1] +
+                                  reduced_basis[l][2] * vec[k][2]);
+                    length[k] += length_tmp * length_tmp;
+                }
+                length[k] = sqrt(length[k]);
+            }
+
+            minimum = DBL_MAX;
+            for (k = 0; k < num_lattice_points; k++) {
+                if (length[k] < minimum) {
+                    minimum = length[k];
+                }
+            }
+
+            count = 0;
+            for (k = 0; k < num_lattice_points; k++) {
+                if (length[k] - minimum < symprec) {
+                    for (l = 0; l < 3; l++) {
+                        /* Transform back to supercell coordinates */
+                        vec_xyz = (trans_mat[l][0] * vec[k][0] +
+                                   trans_mat[l][1] * vec[k][1] +
+                                   trans_mat[l][2] * vec[k][2]);
+                        smallest_vectors[i * num_pos_from + j][count][l] =
+                            vec_xyz;
+                    }
+                    count++;
+                }
+            }
+            if (count > 27) { /* should not be greater than 27 */
+                printf("Warning (gsv_set_smallest_vectors_sparse): ");
+                printf("number of shortest vectors is out of range,\n");
+                break;
+            } else {
+                multiplicity[i * num_pos_from + j] = count;
+            }
+        }
+    }
+
+    free(length);
+    length = NULL;
+    free(vec);
+    vec = NULL;
+}
+
+void phpy_set_smallest_vectors_dense(
+    double (*smallest_vectors)[3], int64_t (*multiplicity)[2],
+    const double (*pos_to)[3], const int64_t num_pos_to,
+    const double (*pos_from)[3], const int64_t num_pos_from,
+    const int64_t (*lattice_points)[3], const int64_t num_lattice_points,
+    const double reduced_basis[3][3], const int64_t trans_mat[3][3],
+    const int64_t initialize, const double symprec) {
+    int64_t i, j, k, l, count, adrs;
+    double length_tmp, minimum, vec_xyz;
+    double *length;
+    double (*vec)[3];
+
+    length = (double *)malloc(sizeof(double) * num_lattice_points);
+    vec = (double (*)[3])malloc(sizeof(double[3]) * num_lattice_points);
+
+    adrs = 0;
+
+    for (i = 0; i < num_pos_to; i++) {
+        for (j = 0; j < num_pos_from; j++) {
+            for (k = 0; k < num_lattice_points; k++) {
+                length[k] = 0;
+                for (l = 0; l < 3; l++) {
+                    vec[k][l] =
+                        pos_to[i][l] - pos_from[j][l] + lattice_points[k][l];
+                }
+                for (l = 0; l < 3; l++) {
+                    length_tmp = (reduced_basis[l][0] * vec[k][0] +
+                                  reduced_basis[l][1] * vec[k][1] +
+                                  reduced_basis[l][2] * vec[k][2]);
+                    length[k] += length_tmp * length_tmp;
+                }
+                length[k] = sqrt(length[k]);
+            }
+
+            minimum = DBL_MAX;
+            for (k = 0; k < num_lattice_points; k++) {
+                if (length[k] < minimum) {
+                    minimum = length[k];
+                }
+            }
+
+            count = 0;
+            for (k = 0; k < num_lattice_points; k++) {
+                if (length[k] - minimum < symprec) {
+                    if (!initialize) {
+                        for (l = 0; l < 3; l++) {
+                            /* Transform back to supercell coordinates */
+                            vec_xyz = (trans_mat[l][0] * vec[k][0] +
+                                       trans_mat[l][1] * vec[k][1] +
+                                       trans_mat[l][2] * vec[k][2]);
+                            smallest_vectors[adrs + count][l] = vec_xyz;
+                        }
+                    }
+                    count++;
+                }
+            }
+            if (initialize) {
+                multiplicity[i * num_pos_from + j][0] = count;
+                multiplicity[i * num_pos_from + j][1] = adrs;
+            }
+            adrs += count;
+        }
+    }
+
+    free(length);
+    length = NULL;
+    free(vec);
+    vec = NULL;
+}
+
+void phpy_perm_trans_symmetrize_fc(double *fc, const int n_satom,
+                                   const int level) {
+    int i, j, k, l, iter;
+    double sum;
+
+    for (iter = 0; iter < level; iter++) {
+        /* Subtract drift aint64_t column */
+        for (j = 0; j < n_satom; j++) {
+            for (k = 0; k < 3; k++) {
+                for (l = 0; l < 3; l++) {
+                    sum = 0;
+                    for (i = 0; i < n_satom; i++) {
+                        sum += fc[i * n_satom * 9 + j * 9 + k * 3 + l];
+                    }
+                    sum /= n_satom;
+                    for (i = 0; i < n_satom; i++) {
+                        fc[i * n_satom * 9 + j * 9 + k * 3 + l] -= sum;
+                    }
+                }
+            }
+        }
+        /* Subtract drift aint64_t row */
+        for (i = 0; i < n_satom; i++) {
+            for (k = 0; k < 3; k++) {
+                for (l = 0; l < 3; l++) {
+                    sum = 0;
+                    for (j = 0; j < n_satom; j++) {
+                        sum += fc[i * n_satom * 9 + j * 9 + k * 3 + l];
+                    }
+                    sum /= n_satom;
+                    for (j = 0; j < n_satom; j++) {
+                        fc[i * n_satom * 9 + j * 9 + k * 3 + l] -= sum;
+                    }
+                }
+            }
+        }
+        set_index_permutation_symmetry_fc(fc, n_satom);
+    }
+    set_translational_symmetry_fc(fc, n_satom);
+}
+
+void phpy_perm_trans_symmetrize_compact_fc(double *fc, const int p2s[],
+                                           const int s2pp[],
+                                           const int nsym_list[],
+                                           const int perms[], const int n_satom,
+                                           const int n_patom, const int level) {
+    int i, j, k, l, n, iter;
+    double sum;
+
+    for (iter = 0; iter < level; iter++) {
+        for (n = 0; n < 2; n++) {
+            /* transpose only */
+            phpy_set_index_permutation_symmetry_compact_fc(
+                fc, p2s, s2pp, nsym_list, perms, n_satom, n_patom, 1);
+            for (i = 0; i < n_patom; i++) {
+                for (k = 0; k < 3; k++) {
+                    for (l = 0; l < 3; l++) {
+                        sum = 0;
+                        for (j = 0; j < n_satom; j++) {
+                            sum += fc[i * n_satom * 9 + j * 9 + k * 3 + l];
+                        }
+                        sum /= n_satom;
+                        for (j = 0; j < n_satom; j++) {
+                            fc[i * n_satom * 9 + j * 9 + k * 3 + l] -= sum;
+                        }
+                    }
+                }
+            }
+        }
+
+        phpy_set_index_permutation_symmetry_compact_fc(
+            fc, p2s, s2pp, nsym_list, perms, n_satom, n_patom, 0);
+    }
+
+    set_translational_symmetry_compact_fc(fc, p2s, n_satom, n_patom);
+}
+
+void phpy_set_index_permutation_symmetry_compact_fc(
+    double *fc, const int p2s[], const int s2pp[], const int nsym_list[],
+    const int perms[], const int n_satom, const int n_patom,
+    const int is_transpose) {
+    int i, j, k, l, m, n, i_p, j_p, i_trans;
+    double fc_elem;
+    char *done;
+
+    done = NULL;
+    done = (char *)malloc(sizeof(char) * n_satom * n_patom);
+    for (i = 0; i < n_satom * n_patom; i++) {
+        done[i] = 0;
+    }
+
+    for (j = 0; j < n_satom; j++) {
+        j_p = s2pp[j];
+        for (i_p = 0; i_p < n_patom; i_p++) {
+            i = p2s[i_p];
+            if (i == j) { /* diagnoal part */
+                for (k = 0; k < 3; k++) {
+                    for (l = 0; l < 3; l++) {
+                        if (l > k) {
+                            m = i_p * n_satom * 9 + i * 9 + k * 3 + l;
+                            n = i_p * n_satom * 9 + i * 9 + l * 3 + k;
+                            if (is_transpose) {
+                                fc_elem = fc[m];
+                                fc[m] = fc[n];
+                                fc[n] = fc_elem;
+                            } else {
+                                fc[m] = (fc[m] + fc[n]) / 2;
+                                fc[n] = fc[m];
+                            }
+                        }
+                    }
+                }
+            }
+            if (!done[i_p * n_satom + j]) {
+                /* (j, i) -- nsym_list[j] --> (j', i') */
+                /* nsym_list[j] translates j to j' where j' is in */
+                /* primitive cell. The same translation sends i to i' */
+                /* where i' is not necessarily to be in primitive cell. */
+                /* Thus, i' = perms[nsym_list[j] * n_satom + i] */
+                i_trans = perms[nsym_list[j] * n_satom + i];
+                done[i_p * n_satom + j] = 1;
+                done[j_p * n_satom + i_trans] = 1;
+                for (k = 0; k < 3; k++) {
+                    for (l = 0; l < 3; l++) {
+                        m = i_p * n_satom * 9 + j * 9 + k * 3 + l;
+                        n = j_p * n_satom * 9 + i_trans * 9 + l * 3 + k;
+                        if (is_transpose) {
+                            fc_elem = fc[m];
+                            fc[m] = fc[n];
+                            fc[n] = fc_elem;
+                        } else {
+                            fc[m] = (fc[n] + fc[m]) / 2;
+                            fc[n] = fc[m];
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    free(done);
+    done = NULL;
+}
+
+int64_t phpy_use_openmp(void) {
+#ifdef _OPENMP
+    return 1;
+#else
+    return 0;
+#endif
+}
+
+int64_t phpy_get_max_threads(void) {
+#ifdef _OPENMP
+    return omp_get_max_threads();
+#else
+    return 0;
+#endif
+}
+
+static void set_index_permutation_symmetry_fc(double *fc, const int natom) {
+    int i, j, k, l, m, n;
+
+    for (i = 0; i < natom; i++) {
+        /* non diagonal part */
+        for (j = i + 1; j < natom; j++) {
+            for (k = 0; k < 3; k++) {
+                for (l = 0; l < 3; l++) {
+                    m = i * natom * 9 + j * 9 + k * 3 + l;
+                    n = j * natom * 9 + i * 9 + l * 3 + k;
+                    fc[m] += fc[n];
+                    fc[m] /= 2;
+                    fc[n] = fc[m];
+                }
+            }
+        }
+
+        /* diagnoal part */
+        for (k = 0; k < 2; k++) {
+            for (l = k + 1; l < 3; l++) {
+                m = i * natom * 9 + i * 9 + k * 3 + l;
+                n = i * natom * 9 + i * 9 + l * 3 + k;
+                fc[m] += fc[n];
+                fc[m] /= 2;
+                fc[n] = fc[m];
+            }
+        }
+    }
+}
+
+static void set_translational_symmetry_fc(double *fc, const int natom) {
+    int i, j, k, l, m;
+    double sums[3][3];
+
+    for (i = 0; i < natom; i++) {
+        for (k = 0; k < 3; k++) {
+            for (l = 0; l < 3; l++) {
+                sums[k][l] = 0;
+                m = i * natom * 9 + k * 3 + l;
+                for (j = 0; j < natom; j++) {
+                    if (i != j) {
+                        sums[k][l] += fc[m];
+                    }
+                    m += 9;
+                }
+            }
+        }
+        for (k = 0; k < 3; k++) {
+            for (l = 0; l < 3; l++) {
+                fc[i * natom * 9 + i * 9 + k * 3 + l] =
+                    -(sums[k][l] + sums[l][k]) / 2;
+            }
+        }
+    }
+}
+
+static void set_translational_symmetry_compact_fc(double *fc, const int p2s[],
+                                                  const int n_satom,
+                                                  const int n_patom) {
+    int j, k, l, m, i_p;
+    double sums[3][3];
+
+    for (i_p = 0; i_p < n_patom; i_p++) {
+        for (k = 0; k < 3; k++) {
+            for (l = 0; l < 3; l++) {
+                sums[k][l] = 0;
+                m = i_p * n_satom * 9 + k * 3 + l;
+                for (j = 0; j < n_satom; j++) {
+                    if (p2s[i_p] != j) {
+                        sums[k][l] += fc[m];
+                    }
+                    m += 9;
+                }
+            }
+        }
+        for (k = 0; k < 3; k++) {
+            for (l = 0; l < 3; l++) {
+                fc[i_p * n_satom * 9 + p2s[i_p] * 9 + k * 3 + l] =
+                    -(sums[k][l] + sums[l][k]) / 2;
+            }
+        }
+    }
+}
+
+static double get_free_energy(const double temperature, const double f,
+                              const double KB, const int classical) {
+    /* temperature is defined by T (K) */
+    /* 'f' must be given in eV. */
+    if (classical) {
+        return KB * temperature * log(f / (KB * temperature));
+    } else {
+        return KB * temperature * log(1 - exp(-f / (KB * temperature)));
+    }
+}
+
+static double get_entropy(const double temperature, const double f,
+                          const double KB, const int classical) {
+    /* temperature is defined by T (K) */
+    /* 'f' must be given in eV. */
+    double val;
+    if (classical) {
+        return KB - KB * log(f / (KB * temperature));
+    } else {
+        val = f / (2 * KB * temperature);
+        return 1 / (2 * temperature) * f * cosh(val) / sinh(val) -
+               KB * log(2 * sinh(val));
+    }
+}
+
+static double get_heat_capacity(const double temperature, const double f,
+                                const double KB, const int classical) {
+    /* temperature is defined by T (K) */
+    /* 'f' must be given in eV. */
+    /* If val is close to 1. Then expansion is used. */
+    double val, val1, val2;
+    if (classical) {
+        return KB;
+    } else {
+        val = f / (KB * temperature);
+        val1 = exp(val);
+        val2 = (val) / (val1 - 1);
+        return KB * val1 * val2 * val2;
+    }
+}
+
+static void distribute_fc2(double (*fc2)[3][3], /* shape[n_pos][n_pos] */
+                           const int *atom_list, const int len_atom_list,
+                           const int *fc_indices_of_atom_list,
+                           const double (*r_carts)[3][3], /* shape[n_rot] */
+                           const int *permutations, /* shape[n_rot][n_pos] */
+                           const int *map_atoms,    /* shape [n_pos] */
+                           const int *map_syms,     /* shape [n_pos] */
+                           const int num_rot, const int num_pos) {
+    int i, j, k, l, m;
+    int atom_todo, atom_done, atom_other;
+    int sym_index;
+    int *atom_list_reverse;
+    double (*fc2_done)[3];
+    double (*fc2_todo)[3];
+    const double (*r_cart)[3];
+    const int *permutation;
+
+    atom_list_reverse = NULL;
+    atom_list_reverse = (int *)malloc(sizeof(int) * num_pos);
+    /* atom_list_reverse[!atom_done] is undefined. */
+    for (i = 0; i < len_atom_list; i++) {
+        atom_done = map_atoms[atom_list[i]];
+        if (atom_done == atom_list[i]) {
+            atom_list_reverse[atom_done] = i;
+        }
+    }
+
+    for (i = 0; i < len_atom_list; i++) {
+        /* look up how this atom maps into the done list. */
+        atom_todo = atom_list[i];
+        atom_done = map_atoms[atom_todo];
+        sym_index = map_syms[atom_todo];
+
+        /* skip the atoms in the done list, */
+        /* which are easily identified because they map to themselves. */
+        if (atom_todo == atom_done) {
+            continue;
+        }
+
+        /* look up information about the rotation */
+        r_cart = r_carts[sym_index];
+        permutation = &permutations[sym_index * num_pos]; /* shape[num_pos] */
+
+        /* distribute terms from atom_done to atom_todo */
+        for (atom_other = 0; atom_other < num_pos; atom_other++) {
+            fc2_done =
+                fc2[fc_indices_of_atom_list[atom_list_reverse[atom_done]] *
+                        num_pos +
+                    permutation[atom_other]];
+            fc2_todo = fc2[fc_indices_of_atom_list[i] * num_pos + atom_other];
+            for (j = 0; j < 3; j++) {
+                for (k = 0; k < 3; k++) {
+                    for (l = 0; l < 3; l++) {
+                        for (m = 0; m < 3; m++) {
+                            /* P' = R^-1 P R */
+                            fc2_todo[j][k] +=
+                                r_cart[l][j] * r_cart[m][k] * fc2_done[l][m];
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    free(atom_list_reverse);
+    atom_list_reverse = NULL;
+}
+
+/* static double get_energy(double temperature, double f){ */
+/*   /\* temperature is defined by T (K) *\/ */
+/*   /\* 'f' must be given in eV. *\/ */
+/*   return f / (exp(f / (KB * temperature)) - 1); */
+/* } */
+
+static int nint(const double a) {
+    if (a < 0.0)
+        return (int)(a - 0.5);
+    else
+        return (int)(a + 0.5);
+}

phonopy/source/c/phonopy.h

@@ -0,0 +1,160 @@
+/* Copyright (C) 2021 Atsushi Togo */
+/* All rights reserved. */
+
+/* This file is part of phonopy. */
+
+/* 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 __phonopy_H__
+#define __phonopy_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+
+void phpy_transform_dynmat_to_fc(
+    double *fc, const double (*dm)[2], const double (*comm_points)[3],
+    const double (*svecs)[3], const int64_t (*multi)[2], const double *masses,
+    const int64_t *s2pp_map, const int64_t *fc_index_map,
+    const int64_t num_patom, const int64_t num_satomconst, int64_t use_openmp);
+int64_t phpy_dynamical_matrices_with_dd_openmp_over_qpoints(
+    double (*dynamical_matrices)[2], const double (*qpoints)[3],
+    const int64_t n_qpoints, const double *fc, const double (*svecs)[3],
+    const int64_t (*multi)[2], const double (*positions)[3],
+    const int64_t num_patom, const int64_t num_satom, const double *masses,
+    const int64_t *p2s_map, const int64_t *s2p_map, const double (*born)[3][3],
+    const double dielectric[3][3], const double (*reciprocal_lattice)[3],
+    const double *q_direction, const double nac_factor,
+    const double (*dd_q0)[2], const double (*G_list)[3],
+    const int64_t num_G_points, const double lambda, const int64_t use_Wang_NAC,
+    const int64_t hermitianize);
+void phpy_get_charge_sum(
+    double (*charge_sum)[3][3], const int64_t num_patom,
+    const double factor, /* 4pi/V*unit-conv and denominator */
+    const double q_cart[3], const double (*born)[3][3]);
+void phpy_get_recip_dipole_dipole(
+    double (*dd)[2],           /* [natom, 3, natom, 3, (real,imag)] */
+    const double (*dd_q0)[2],  /* [natom, 3, 3, (real,imag)] */
+    const double (*G_list)[3], /* [num_G, 3] */
+    const int64_t num_G, const int64_t num_patom, const double q_cart[3],
+    const double *q_direction_cart, /* must be pointer */
+    const double (*born)[3][3], const double dielectric[3][3],
+    const double (*pos)[3], /* [num_patom, 3] */
+    const double factor,    /* 4pi/V*unit-conv */
+    const double lambda, const double tolerance, const int64_t use_openmp);
+void phpy_get_recip_dipole_dipole_q0(
+    double (*dd_q0)[2],        /* [natom, 3, 3, (real,imag)] */
+    const double (*G_list)[3], /* [num_G, 3] */
+    const int64_t num_G, const int64_t num_patom, const double (*born)[3][3],
+    const double dielectric[3][3], const double (*pos)[3], /* [num_patom, 3] */
+    const double lambda, const double tolerance, const int64_t use_openmp);
+void phpy_get_derivative_dynmat_at_q(
+    double (*derivative_dynmat)[2], const int64_t num_patom,
+    const int64_t num_satom, const double *fc, const double *q,
+    const double *lattice, /* column vector */
+    const double *reclat,  /* column vector */
+    const double (*svecs)[3], const int64_t (*multi)[2], const double *mass,
+    const int64_t *s2p_map, const int64_t *p2s_map, const double nac_factor,
+    const double *born, const double *dielectric, const double *q_direction,
+    const int64_t is_nac, const int64_t use_openmp);
+void phpy_get_neighboring_grid_points(
+    size_t neighboring_grid_points[], const size_t grid_point,
+    const int relative_grid_address[][3], const int num_relative_grid_address,
+    const int mesh[3], const int bz_grid_address[][3], const size_t bz_map[]);
+void phpy_get_relative_grid_address(int64_t relative_grid_address[24][4][3],
+                                    const double reciprocal_lattice[3][3]);
+void phpy_get_all_relative_grid_address(
+    int64_t relative_grid_address[4][24][4][3]);
+double phpy_get_integration_weight(const double omega,
+                                   const double tetrahedra_omegas[24][4],
+                                   const char function);
+void phpy_get_tetrahedra_frequenies(
+    double *freq_tetras, const int64_t mesh[3], const int64_t *grid_points,
+    const int64_t (*grid_address)[3], const int64_t (*relative_grid_address)[3],
+    const int64_t *gp_ir_index, const double *frequencies,
+    const int64_t num_band, const int64_t num_gp);
+void phpy_tetrahedron_method_dos(
+    double *dos, const int64_t mesh[3], const int64_t (*grid_address)[3],
+    const int64_t (*relative_grid_address)[4][3],
+    const int64_t *grid_mapping_table, const double *freq_points,
+    const double *frequencies, const double *coef,
+    const int64_t num_freq_points, const int64_t num_ir_gp,
+    const int64_t num_band, const int64_t num_coef, const int64_t num_gp);
+void phpy_get_thermal_properties(
+    double *thermal_props, const double *temperatures, const double *freqs,
+    const int64_t *weights, const int64_t num_temp, const int64_t num_qpoints,
+    const int64_t num_bands, const double cutoff_frequency, const double KB,
+    const int classical);
+void phpy_distribute_fc2(double (*fc2)[3][3], const int *atom_list,
+                         const int len_atom_list,
+                         const int *fc_indices_of_atom_list,
+                         const double (*r_carts)[3][3], const int *permutations,
+                         const int *map_atoms, const int *map_syms,
+                         const int num_rot, const int num_pos);
+int phpy_compute_permutation(int *rot_atom, const double lat[3][3],
+                             const double (*pos)[3], const double (*rot_pos)[3],
+                             const int num_pos, const double symprec);
+void phpy_set_smallest_vectors_sparse(
+    double (*smallest_vectors)[27][3], int *multiplicity,
+    const double (*pos_to)[3], const int num_pos_to,
+    const double (*pos_from)[3], const int num_pos_from,
+    const int (*lattice_points)[3], const int num_lattice_points,
+    const double reduced_basis[3][3], const int trans_mat[3][3],
+    const double symprec);
+void phpy_set_smallest_vectors_dense(
+    double (*smallest_vectors)[3], int64_t (*multiplicity)[2],
+    const double (*pos_to)[3], const int64_t num_pos_to,
+    const double (*pos_from)[3], const int64_t num_pos_from,
+    const int64_t (*lattice_points)[3], const int64_t num_lattice_points,
+    const double reduced_basis[3][3], const int64_t trans_mat[3][3],
+    const int64_t initialize, const double symprec);
+
+void phpy_perm_trans_symmetrize_fc(double *fc, const int nsatom,
+                                   const int level);
+void phpy_perm_trans_symmetrize_compact_fc(double *fc, const int p2s[],
+                                           const int s2pp[],
+                                           const int nsym_list[],
+                                           const int perms[], const int n_satom,
+                                           const int n_patom, const int level);
+void phpy_set_index_permutation_symmetry_compact_fc(
+    double *fc, const int p2s[], const int s2pp[], const int nsym_list[],
+    const int perms[], const int n_satom, const int n_patom,
+    const int is_transpose);
+int64_t phpy_use_openmp(void);
+int64_t phpy_get_max_threads(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

phonopy/source/c/rgrid.c

@@ -0,0 +1,115 @@
+/* Copyright (C) 2015 Atsushi Togo */
+/* All rights reserved. */
+
+/* This file was originally part of spglib and is part of kspclib. */
+
+/* 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 kspclib 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. */
+
+#include "rgrid.h"
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+static int64_t get_double_grid_index(const int64_t address_double[3],
+                                     const int64_t mesh[3]);
+static int64_t get_grid_index_single_mesh(const int64_t address[3],
+                                          const int64_t mesh[3]);
+static void reduce_double_grid_address(int64_t address[3],
+                                       const int64_t mesh[3]);
+static int64_t mat_modulo_l(const int64_t a, const int64_t b);
+
+int64_t rgd_get_double_grid_index(const int64_t address_double[3],
+                                  const int64_t mesh[3]) {
+    return get_double_grid_index(address_double, mesh);
+}
+
+void rgd_get_double_grid_address(int64_t address_double[3],
+                                 const int64_t address[3],
+                                 const int64_t mesh[3],
+                                 const int64_t is_shift[3]) {
+    int64_t i;
+
+    for (i = 0; i < 3; i++) {
+        address_double[i] = address[i] * 2 + (is_shift[i] != 0);
+    }
+    reduce_double_grid_address(address_double, mesh);
+}
+
+static int64_t get_double_grid_index(const int64_t address_double[3],
+                                     const int64_t mesh[3]) {
+    int64_t i;
+    int64_t address[3];
+
+    for (i = 0; i < 3; i++) {
+        if (address_double[i] % 2 == 0) {
+            address[i] = address_double[i] / 2;
+        } else {
+            address[i] = (address_double[i] - 1) / 2;
+        }
+        address[i] = mat_modulo_l(address[i], mesh[i]);
+    }
+
+    return get_grid_index_single_mesh(address, mesh);
+}
+
+static int64_t get_grid_index_single_mesh(const int64_t address[3],
+                                          const int64_t mesh[3]) {
+#ifndef GRID_ORDER_XYZ
+    return (address[2] * mesh[0] * (int64_t)(mesh[1]) + address[1] * mesh[0] +
+            address[0]);
+#else
+    return (address[0] * mesh[1] * (int64_t)(mesh[2]) + address[1] * mesh[2] +
+            address[2]);
+#endif
+}
+
+static void reduce_double_grid_address(int64_t address[3],
+                                       const int64_t mesh[3]) {
+    int64_t i;
+
+    for (i = 0; i < 3; i++) {
+#ifndef GRID_BOUNDARY_AS_NEGATIVE
+        address[i] -= 2 * mesh[i] * (address[i] > mesh[i]);
+#else
+        address[i] -= 2 * mesh[i] * (address[i] > mesh[i] - 1);
+#endif
+    }
+}
+
+static int64_t mat_modulo_l(const int64_t a, const int64_t b) {
+    int64_t c;
+    c = a % b;
+    if (c < 0) {
+        c += b;
+    }
+    return c;
+}

phonopy/source/c/rgrid.h

@@ -0,0 +1,82 @@
+/* Copyright (C) 2015 Atsushi Togo */
+/* All rights reserved. */
+
+/* This file was originally part of spglib and is part of kspclib. */
+
+/* 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 kspclib 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 __rgrid_H__
+#define __rgrid_H__
+
+#include <stdint.h>
+
+/* #define GRID_ORDER_XYZ */
+/* This changes behaviour of index order of address. */
+/* Without GRID_ORDER_XYZ, left most element of address runs first. */
+/* grid_address (e.g. 4x4x4 mesh, unless GRID_ORDER_XYZ is defined) */
+/*    [[ 0  0  0]                                                   */
+/*     [ 1  0  0]                                                   */
+/*     [ 2  0  0]                                                   */
+/*     [-1  0  0]                                                   */
+/*     [ 0  1  0]                                                   */
+/*     [ 1  1  0]                                                   */
+/*     [ 2  1  0]                                                   */
+/*     [-1  1  0]                                                   */
+/*     ....      ]                                                  */
+/*                                                                  */
+/* With GRID_ORDER_XYZ, right most element of address runs first.   */
+/* grid_address (e.g. 4x4x4 mesh, if GRID_ORDER_XYZ is defined)     */
+/*    [[ 0  0  0]                                                   */
+/*     [ 0  0  1]                                                   */
+/*     [ 0  0  2]                                                   */
+/*     [ 0  0 -1]                                                   */
+/*     [ 0  1  0]                                                   */
+/*     [ 0  1  1]                                                   */
+/*     [ 0  1  2]                                                   */
+/*     [ 0  1 -1]                                                   */
+/*     ....      ]                                                  */
+
+/* #define GRID_BOUNDARY_AS_NEGATIVE */
+/* This changes the behaviour of address elements on the surface of  */
+/* parallelepiped. */
+/* For odd mesh number, this affects nothing, e.g., [-2, -1, 0, 1, 2]. */
+/* regardless of with and without GRID_BOUNDARY_AS_NEGATIVE. */
+/* For even mesh number, this affects as follows: */
+/* without GRID_BOUNDARY_AS_NEGATIVE, e.g., [-2, -1, 0, 1, 2, 3]. */
+/* with GRID_BOUNDARY_AS_NEGATIVE, e.g., [-3, -2, -1, 0, 1, 2]. */
+
+int64_t rgd_get_double_grid_index(const int64_t address_double[3],
+                                  const int64_t mesh[3]);
+void rgd_get_double_grid_address(int64_t address_double[3],
+                                 const int64_t address[3],
+                                 const int64_t mesh[3],
+                                 const int64_t is_shift[3]);
+
+#endif

phonopy/source/c/tetrahedron_method.c

@@ -0,0 +1,1455 @@
+/* Copyright (C) 2014 Atsushi Togo */
+/* All rights reserved. */
+
+/* This file was originally part of spglib and is part of kspclib. */
+
+/* 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 kspclib 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. */
+/* tetrahedron_method.c */
+/* Copyright (C) 2014 Atsushi Togo */
+
+#include "tetrahedron_method.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef THMWARNING
+#include <stdio.h>
+#define warning_print(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define warning_print(...)
+#endif
+
+#ifdef THM_EPSILON
+#include <math.h>
+#endif
+
+/*      6-------7             */
+/*     /|      /|             */
+/*    / |     / |             */
+/*   4-------5  |             */
+/*   |  2----|--3             */
+/*   | /     | /              */
+/*   |/      |/                       */
+/*   0-------1                */
+/*                            */
+/*  i: vec        neighbours  */
+/*  0: O          1, 2, 4     */
+/*  1: a          0, 3, 5     */
+/*  2: b          0, 3, 6     */
+/*  3: a + b      1, 2, 7     */
+/*  4: c          0, 5, 6     */
+/*  5: c + a      1, 4, 7     */
+/*  6: c + b      2, 4, 7     */
+/*  7: c + a + b  3, 5, 6     */
+
+static int64_t main_diagonals[4][3] = {{1, 1, 1},   /* 0-7 */
+                                       {-1, 1, 1},  /* 1-6 */
+                                       {1, -1, 1},  /* 2-5 */
+                                       {1, 1, -1}}; /* 3-4 */
+
+static int64_t db_relative_grid_address[4][24][4][3] = {
+    {
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {1, 1, 0},
+            {1, 1, 1},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {1, 0, 1},
+            {1, 1, 1},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {1, 1, 0},
+            {1, 1, 1},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {0, 1, 1},
+            {1, 1, 1},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, 1},
+            {1, 0, 1},
+            {1, 1, 1},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, 1},
+            {0, 1, 1},
+            {1, 1, 1},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {0, 1, 1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, 1},
+            {0, 1, 1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {1, 0, 1},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, 1},
+            {1, 0, 1},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, 1},
+            {-1, -1, 0},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, 1},
+            {-1, -1, 0},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {1, 1, 0},
+            {0, 0, -1},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {1, 1, 0},
+            {0, 0, -1},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {-1, 0, -1},
+            {0, 0, -1},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {-1, 0, -1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {0, -1, -1},
+            {0, 0, -1},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {0, -1, -1},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, -1, -1},
+            {0, -1, -1},
+            {0, 0, -1},
+        },
+        {
+            {0, 0, 0},
+            {-1, -1, -1},
+            {0, -1, -1},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, -1, -1},
+            {-1, 0, -1},
+            {0, 0, -1},
+        },
+        {
+            {0, 0, 0},
+            {-1, -1, -1},
+            {-1, 0, -1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, -1, -1},
+            {-1, -1, 0},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, -1, -1},
+            {-1, -1, 0},
+            {-1, 0, 0},
+        },
+    },
+    {
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {0, 1, 0},
+            {0, 1, 1},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {0, 0, 1},
+            {0, 1, 1},
+        },
+        {
+            {0, 0, 0},
+            {-1, 1, 0},
+            {-1, 1, 1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, 0, 1},
+            {-1, 1, 1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, 1, 0},
+            {0, 1, 0},
+            {-1, 1, 1},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {-1, 1, 1},
+            {0, 1, 1},
+        },
+        {
+            {0, 0, 0},
+            {-1, 0, 1},
+            {0, 0, 1},
+            {-1, 1, 1},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, 1},
+            {-1, 1, 1},
+            {0, 1, 1},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, 1},
+            {0, -1, 0},
+            {1, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {0, 0, 1},
+            {1, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, 0, 1},
+            {0, -1, 0},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, 0, 1},
+            {0, 0, 1},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {0, 0, -1},
+            {1, 0, -1},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {0, 1, 0},
+            {1, 0, -1},
+        },
+        {
+            {0, 0, 0},
+            {-1, 1, 0},
+            {0, 0, -1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, 1, 0},
+            {0, 1, 0},
+            {0, 0, -1},
+        },
+        {
+            {0, 0, 0},
+            {0, -1, -1},
+            {1, -1, -1},
+            {0, 0, -1},
+        },
+        {
+            {0, 0, 0},
+            {0, -1, -1},
+            {1, -1, -1},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {1, -1, -1},
+            {0, 0, -1},
+            {1, 0, -1},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {1, -1, -1},
+            {1, 0, -1},
+        },
+        {
+            {0, 0, 0},
+            {1, -1, -1},
+            {0, -1, 0},
+            {1, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {1, -1, -1},
+            {1, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, -1, -1},
+            {0, 0, -1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, -1, -1},
+            {0, -1, 0},
+            {-1, 0, 0},
+        },
+    },
+    {
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {0, 1, 0},
+            {1, 0, 1},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {0, 0, 1},
+            {1, 0, 1},
+        },
+        {
+            {0, 0, 0},
+            {-1, 1, 0},
+            {0, 0, 1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, 1, 0},
+            {0, 1, 0},
+            {0, 0, 1},
+        },
+        {
+            {0, 0, 0},
+            {1, -1, 1},
+            {0, -1, 0},
+            {1, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, -1, 1},
+            {1, -1, 1},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {1, -1, 1},
+            {1, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {1, -1, 1},
+            {1, 0, 1},
+        },
+        {
+            {0, 0, 0},
+            {0, -1, 1},
+            {1, -1, 1},
+            {0, 0, 1},
+        },
+        {
+            {0, 0, 0},
+            {1, -1, 1},
+            {0, 0, 1},
+            {1, 0, 1},
+        },
+        {
+            {0, 0, 0},
+            {0, -1, 1},
+            {0, -1, 0},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, -1, 1},
+            {0, 0, 1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {0, 0, -1},
+            {0, 1, -1},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {0, 1, 0},
+            {0, 1, -1},
+        },
+        {
+            {0, 0, 0},
+            {-1, 0, -1},
+            {0, 0, -1},
+            {-1, 1, -1},
+        },
+        {
+            {0, 0, 0},
+            {-1, 0, -1},
+            {-1, 1, -1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, -1},
+            {-1, 1, -1},
+            {0, 1, -1},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {-1, 1, -1},
+            {0, 1, -1},
+        },
+        {
+            {0, 0, 0},
+            {-1, 1, 0},
+            {-1, 1, -1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, 1, 0},
+            {0, 1, 0},
+            {-1, 1, -1},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, -1},
+            {0, -1, 0},
+            {1, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {0, 0, -1},
+            {1, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, 0, -1},
+            {0, 0, -1},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, 0, -1},
+            {0, -1, 0},
+            {-1, 0, 0},
+        },
+    },
+    {
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {1, 1, 0},
+            {0, 0, 1},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {1, 1, 0},
+            {0, 0, 1},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {-1, 0, 1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {-1, 0, 1},
+            {0, 0, 1},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {0, -1, 1},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {0, -1, 1},
+            {0, 0, 1},
+        },
+        {
+            {0, 0, 0},
+            {-1, -1, 1},
+            {-1, -1, 0},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, -1, 1},
+            {-1, -1, 0},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, -1, 1},
+            {0, -1, 1},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, -1, 1},
+            {-1, 0, 1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {-1, -1, 1},
+            {0, -1, 1},
+            {0, 0, 1},
+        },
+        {
+            {0, 0, 0},
+            {-1, -1, 1},
+            {-1, 0, 1},
+            {0, 0, 1},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, -1},
+            {1, 0, -1},
+            {1, 1, -1},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, -1},
+            {0, 1, -1},
+            {1, 1, -1},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {1, 0, -1},
+            {1, 1, -1},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {0, 1, -1},
+            {1, 1, -1},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {1, 1, 0},
+            {1, 1, -1},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {1, 1, 0},
+            {1, 1, -1},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, -1},
+            {0, 1, -1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, 1, 0},
+            {0, 1, -1},
+            {-1, 0, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, -1},
+            {1, 0, -1},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {1, 0, 0},
+            {1, 0, -1},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, -1},
+            {-1, -1, 0},
+            {0, -1, 0},
+        },
+        {
+            {0, 0, 0},
+            {0, 0, -1},
+            {-1, -1, 0},
+            {-1, 0, 0},
+        },
+    },
+};
+
+static double get_integration_weight(
+    const double omega, const double tetrahedra_omegas[24][4],
+    double (*gn)(const int64_t, const double, const double[4]),
+    double (*IJ)(const int64_t, const int64_t, const double, const double[4]));
+static int64_t get_main_diagonal(const double rec_lattice[3][3]);
+static int64_t sort_omegas(double v[4]);
+static double norm_squared_d3(const double a[3]);
+static void multiply_matrix_vector_dl3(double v[3], const double a[3][3],
+                                       const int64_t b[3]);
+static double _f(const int64_t n, const int64_t m, const double omega,
+                 const double vertices_omegas[4]);
+static double _J(const int64_t i, const int64_t ci, const double omega,
+                 const double vertices_omegas[4]);
+static double _I(const int64_t i, const int64_t ci, const double omega,
+                 const double vertices_omegas[4]);
+static double _n(const int64_t i, const double omega,
+                 const double vertices_omegas[4]);
+static double _g(const int64_t i, const double omega,
+                 const double vertices_omegas[4]);
+static double _n_0(void);
+static double _n_1(const double omega, const double vertices_omegas[4]);
+static double _n_2(const double omega, const double vertices_omegas[4]);
+static double _n_3(const double omega, const double vertices_omegas[4]);
+static double _n_4(void);
+static double _g_0(void);
+static double _g_1(const double omega, const double vertices_omegas[4]);
+static double _g_2(const double omega, const double vertices_omegas[4]);
+static double _g_3(const double omega, const double vertices_omegas[4]);
+static double _g_4(void);
+static double _J_0(void);
+static double _J_10(const double omega, const double vertices_omegas[4]);
+static double _J_11(const double omega, const double vertices_omegas[4]);
+static double _J_12(const double omega, const double vertices_omegas[4]);
+static double _J_13(const double omega, const double vertices_omegas[4]);
+static double _J_20(const double omega, const double vertices_omegas[4]);
+static double _J_21(const double omega, const double vertices_omegas[4]);
+static double _J_22(const double omega, const double vertices_omegas[4]);
+static double _J_23(const double omega, const double vertices_omegas[4]);
+static double _J_30(const double omega, const double vertices_omegas[4]);
+static double _J_31(const double omega, const double vertices_omegas[4]);
+static double _J_32(const double omega, const double vertices_omegas[4]);
+static double _J_33(const double omega, const double vertices_omegas[4]);
+static double _J_4(void);
+static double _I_0(void);
+static double _I_10(const double omega, const double vertices_omegas[4]);
+static double _I_11(const double omega, const double vertices_omegas[4]);
+static double _I_12(const double omega, const double vertices_omegas[4]);
+static double _I_13(const double omega, const double vertices_omegas[4]);
+static double _I_20(const double omega, const double vertices_omegas[4]);
+static double _I_21(const double omega, const double vertices_omegas[4]);
+static double _I_22(const double omega, const double vertices_omegas[4]);
+static double _I_23(const double omega, const double vertices_omegas[4]);
+static double _I_30(const double omega, const double vertices_omegas[4]);
+static double _I_31(const double omega, const double vertices_omegas[4]);
+static double _I_32(const double omega, const double vertices_omegas[4]);
+static double _I_33(const double omega, const double vertices_omegas[4]);
+static double _I_4(void);
+
+void thm_get_relative_grid_address(int64_t relative_grid_address[24][4][3],
+                                   const double rec_lattice[3][3]) {
+    int64_t i, j, k, main_diag_index;
+
+    main_diag_index = get_main_diagonal(rec_lattice);
+
+    for (i = 0; i < 24; i++) {
+        for (j = 0; j < 4; j++) {
+            for (k = 0; k < 3; k++) {
+                relative_grid_address[i][j][k] =
+                    db_relative_grid_address[main_diag_index][i][j][k];
+            }
+        }
+    }
+}
+
+void thm_get_all_relative_grid_address(
+    int64_t relative_grid_address[4][24][4][3]) {
+    int64_t i, j, k, main_diag_index;
+
+    for (main_diag_index = 0; main_diag_index < 4; main_diag_index++) {
+        for (i = 0; i < 24; i++) {
+            for (j = 0; j < 4; j++) {
+                for (k = 0; k < 3; k++) {
+                    relative_grid_address[main_diag_index][i][j][k] =
+                        db_relative_grid_address[main_diag_index][i][j][k];
+                }
+            }
+        }
+    }
+}
+
+double thm_get_integration_weight(const double omega,
+                                  const double tetrahedra_omegas[24][4],
+                                  const char function) {
+    if (function == 'I') {
+        return get_integration_weight(omega, tetrahedra_omegas, _g, _I);
+    } else {
+        return get_integration_weight(omega, tetrahedra_omegas, _n, _J);
+    }
+}
+
+int64_t thm_in_tetrahedra(const double f0, const double freq_vertices[24][4]) {
+    int64_t i, j;
+    double fmin, fmax;
+
+    fmin = freq_vertices[0][0];
+    fmax = freq_vertices[0][0];
+
+    for (i = 0; i < 24; i++) {
+        for (j = 0; j < 4; j++) {
+            if (fmin > freq_vertices[i][j]) {
+                fmin = freq_vertices[i][j];
+            }
+            if (fmax < freq_vertices[i][j]) {
+                fmax = freq_vertices[i][j];
+            }
+        }
+    }
+
+    if (fmin > f0 || fmax < f0) {
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+static double get_integration_weight(
+    const double omega, const double tetrahedra_omegas[24][4],
+    double (*gn)(const int64_t, const double, const double[4]),
+    double (*IJ)(const int64_t, const int64_t, const double, const double[4])) {
+    int64_t i, j, ci;
+    double sum;
+    double v[4];
+
+    sum = 0;
+    for (i = 0; i < 24; i++) {
+        for (j = 0; j < 4; j++) {
+            v[j] = tetrahedra_omegas[i][j];
+        }
+        ci = sort_omegas(v);
+        if (omega < v[0]) {
+            sum += IJ(0, ci, omega, v) * gn(0, omega, v);
+        } else {
+            if (v[0] < omega && omega < v[1]) {
+                sum += IJ(1, ci, omega, v) * gn(1, omega, v);
+            } else {
+                if (v[1] < omega && omega < v[2]) {
+                    sum += IJ(2, ci, omega, v) * gn(2, omega, v);
+                } else {
+                    if (v[2] < omega && omega < v[3]) {
+                        sum += IJ(3, ci, omega, v) * gn(3, omega, v);
+                    } else {
+                        if (v[3] < omega) {
+                            sum += IJ(4, ci, omega, v) * gn(4, omega, v);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return sum / 6;
+}
+
+static int64_t sort_omegas(double v[4]) {
+    int64_t i;
+    double w[4];
+
+    i = 0;
+
+    if (v[0] > v[1]) {
+        w[0] = v[1];
+        w[1] = v[0];
+        i = 1;
+    } else {
+        w[0] = v[0];
+        w[1] = v[1];
+    }
+
+    if (v[2] > v[3]) {
+        w[2] = v[3];
+        w[3] = v[2];
+    } else {
+        w[2] = v[2];
+        w[3] = v[3];
+    }
+
+    if (w[0] > w[2]) {
+        v[0] = w[2];
+        v[1] = w[0];
+        if (i == 0) {
+            i = 4;
+        }
+    } else {
+        v[0] = w[0];
+        v[1] = w[2];
+    }
+
+    if (w[1] > w[3]) {
+        v[3] = w[1];
+        v[2] = w[3];
+        if (i == 1) {
+            i = 3;
+        }
+    } else {
+        v[3] = w[3];
+        v[2] = w[1];
+        if (i == 1) {
+            i = 5;
+        }
+    }
+
+    if (v[1] > v[2]) {
+        w[1] = v[1];
+        v[1] = v[2];
+        v[2] = w[1];
+        if (i == 4) {
+            i = 2;
+        }
+        if (i == 5) {
+            i = 1;
+        }
+    } else {
+        if (i == 4) {
+            i = 1;
+        }
+        if (i == 5) {
+            i = 2;
+        }
+    }
+    return i;
+}
+
+static int64_t get_main_diagonal(const double rec_lattice[3][3]) {
+    int64_t i, shortest;
+    double length, min_length;
+    double main_diag[3];
+
+    shortest = 0;
+    multiply_matrix_vector_dl3(main_diag, rec_lattice, main_diagonals[0]);
+    min_length = norm_squared_d3(main_diag);
+    for (i = 1; i < 4; i++) {
+        multiply_matrix_vector_dl3(main_diag, rec_lattice, main_diagonals[i]);
+        length = norm_squared_d3(main_diag);
+        if (min_length > length) {
+            min_length = length;
+            shortest = i;
+        }
+    }
+    return shortest;
+}
+
+static double norm_squared_d3(const double a[3]) {
+    return a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
+}
+
+static void multiply_matrix_vector_dl3(double v[3], const double a[3][3],
+                                       const int64_t b[3]) {
+    int64_t 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 double _f(const int64_t n, const int64_t m, const double omega,
+                 const double vertices_omegas[4]) {
+    double delta;
+    delta = vertices_omegas[n] - vertices_omegas[m];
+
+#ifdef THM_EPSILON
+    if (fabs(delta) < THM_EPSILON) {
+        return 0;
+    }
+#endif
+
+    return ((omega - vertices_omegas[m]) / delta);
+}
+
+static double _J(const int64_t i, const int64_t ci, const double omega,
+                 const double vertices_omegas[4]) {
+    switch (i) {
+        case 0:
+            return _J_0();
+        case 1:
+            switch (ci) {
+                case 0:
+                    return _J_10(omega, vertices_omegas);
+                case 1:
+                    return _J_11(omega, vertices_omegas);
+                case 2:
+                    return _J_12(omega, vertices_omegas);
+                case 3:
+                    return _J_13(omega, vertices_omegas);
+            }
+        case 2:
+            switch (ci) {
+                case 0:
+                    return _J_20(omega, vertices_omegas);
+                case 1:
+                    return _J_21(omega, vertices_omegas);
+                case 2:
+                    return _J_22(omega, vertices_omegas);
+                case 3:
+                    return _J_23(omega, vertices_omegas);
+            }
+        case 3:
+            switch (ci) {
+                case 0:
+                    return _J_30(omega, vertices_omegas);
+                case 1:
+                    return _J_31(omega, vertices_omegas);
+                case 2:
+                    return _J_32(omega, vertices_omegas);
+                case 3:
+                    return _J_33(omega, vertices_omegas);
+            }
+        case 4:
+            return _J_4();
+    }
+
+    warning_print("******* Warning *******\n");
+    warning_print(" J is something wrong. \n");
+    warning_print("******* Warning *******\n");
+    warning_print("(line %d, %s).\n", __LINE__, __FILE__);
+
+    return 0;
+}
+
+static double _I(const int64_t i, const int64_t ci, const double omega,
+                 const double vertices_omegas[4]) {
+    switch (i) {
+        case 0:
+            return _I_0();
+        case 1:
+            switch (ci) {
+                case 0:
+                    return _I_10(omega, vertices_omegas);
+                case 1:
+                    return _I_11(omega, vertices_omegas);
+                case 2:
+                    return _I_12(omega, vertices_omegas);
+                case 3:
+                    return _I_13(omega, vertices_omegas);
+            }
+        case 2:
+            switch (ci) {
+                case 0:
+                    return _I_20(omega, vertices_omegas);
+                case 1:
+                    return _I_21(omega, vertices_omegas);
+                case 2:
+                    return _I_22(omega, vertices_omegas);
+                case 3:
+                    return _I_23(omega, vertices_omegas);
+            }
+        case 3:
+            switch (ci) {
+                case 0:
+                    return _I_30(omega, vertices_omegas);
+                case 1:
+                    return _I_31(omega, vertices_omegas);
+                case 2:
+                    return _I_32(omega, vertices_omegas);
+                case 3:
+                    return _I_33(omega, vertices_omegas);
+            }
+        case 4:
+            return _I_4();
+    }
+
+    warning_print("******* Warning *******\n");
+    warning_print(" I is something wrong. \n");
+    warning_print("******* Warning *******\n");
+    warning_print("(line %d, %s).\n", __LINE__, __FILE__);
+
+    return 0;
+}
+
+static double _n(const int64_t i, const double omega,
+                 const double vertices_omegas[4]) {
+    switch (i) {
+        case 0:
+            return _n_0();
+        case 1:
+            return _n_1(omega, vertices_omegas);
+        case 2:
+            return _n_2(omega, vertices_omegas);
+        case 3:
+            return _n_3(omega, vertices_omegas);
+        case 4:
+            return _n_4();
+    }
+
+    warning_print("******* Warning *******\n");
+    warning_print(" n is something wrong. \n");
+    warning_print("******* Warning *******\n");
+    warning_print("(line %d, %s).\n", __LINE__, __FILE__);
+
+    return 0;
+}
+
+static double _g(const int64_t i, const double omega,
+                 const double vertices_omegas[4]) {
+    switch (i) {
+        case 0:
+            return _g_0();
+        case 1:
+            return _g_1(omega, vertices_omegas);
+        case 2:
+            return _g_2(omega, vertices_omegas);
+        case 3:
+            return _g_3(omega, vertices_omegas);
+        case 4:
+            return _g_4();
+    }
+
+    warning_print("******* Warning *******\n");
+    warning_print(" g is something wrong. \n");
+    warning_print("******* Warning *******\n");
+    warning_print("(line %d, %s).\n", __LINE__, __FILE__);
+
+    return 0;
+}
+
+/* omega < omega1 */
+static double _n_0(void) { return 0.0; }
+
+/* omega1 < omega < omega2 */
+static double _n_1(const double omega, const double vertices_omegas[4]) {
+    return (_f(1, 0, omega, vertices_omegas) *
+            _f(2, 0, omega, vertices_omegas) *
+            _f(3, 0, omega, vertices_omegas));
+}
+
+/* omega2 < omega < omega3 */
+static double _n_2(const double omega, const double vertices_omegas[4]) {
+    return (
+        _f(3, 1, omega, vertices_omegas) * _f(2, 1, omega, vertices_omegas) +
+        _f(3, 0, omega, vertices_omegas) * _f(1, 3, omega, vertices_omegas) *
+            _f(2, 1, omega, vertices_omegas) +
+        _f(3, 0, omega, vertices_omegas) * _f(2, 0, omega, vertices_omegas) *
+            _f(1, 2, omega, vertices_omegas));
+}
+
+/* omega2 < omega < omega3 */
+static double _n_3(const double omega, const double vertices_omegas[4]) {
+    return (1.0 - _f(0, 3, omega, vertices_omegas) *
+                      _f(1, 3, omega, vertices_omegas) *
+                      _f(2, 3, omega, vertices_omegas));
+}
+
+/* omega4 < omega */
+static double _n_4(void) { return 1.0; }
+
+/* omega < omega1 */
+static double _g_0(void) { return 0.0; }
+
+/* omega1 < omega < omega2 */
+static double _g_1(const double omega, const double vertices_omegas[4]) {
+    return (3 * _f(1, 0, omega, vertices_omegas) *
+            _f(2, 0, omega, vertices_omegas) /
+            (vertices_omegas[3] - vertices_omegas[0]));
+}
+
+/* omega2 < omega < omega3 */
+static double _g_2(const double omega, const double vertices_omegas[4]) {
+    return (
+        3 / (vertices_omegas[3] - vertices_omegas[0]) *
+        (_f(1, 2, omega, vertices_omegas) * _f(2, 0, omega, vertices_omegas) +
+         _f(2, 1, omega, vertices_omegas) * _f(1, 3, omega, vertices_omegas)));
+}
+
+/* omega3 < omega < omega4 */
+static double _g_3(const double omega, const double vertices_omegas[4]) {
+    return (3 * _f(1, 3, omega, vertices_omegas) *
+            _f(2, 3, omega, vertices_omegas) /
+            (vertices_omegas[3] - vertices_omegas[0]));
+}
+
+/* omega4 < omega */
+static double _g_4(void) { return 0.0; }
+
+static double _J_0(void) { return 0.0; }
+
+static double _J_10(const double omega, const double vertices_omegas[4]) {
+    return (1.0 + _f(0, 1, omega, vertices_omegas) +
+            _f(0, 2, omega, vertices_omegas) +
+            _f(0, 3, omega, vertices_omegas)) /
+           4;
+}
+
+static double _J_11(const double omega, const double vertices_omegas[4]) {
+    return _f(1, 0, omega, vertices_omegas) / 4;
+}
+
+static double _J_12(const double omega, const double vertices_omegas[4]) {
+    return _f(2, 0, omega, vertices_omegas) / 4;
+}
+
+static double _J_13(const double omega, const double vertices_omegas[4]) {
+    return _f(3, 0, omega, vertices_omegas) / 4;
+}
+
+static double _J_20(const double omega, const double vertices_omegas[4]) {
+    double n;
+    n = _n_2(omega, vertices_omegas);
+
+#ifdef THM_EPSILON
+    if (n < THM_EPSILON) {
+        return 0;
+    }
+#endif
+
+    return (_f(3, 1, omega, vertices_omegas) *
+                _f(2, 1, omega, vertices_omegas) +
+            _f(3, 0, omega, vertices_omegas) *
+                _f(1, 3, omega, vertices_omegas) *
+                _f(2, 1, omega, vertices_omegas) *
+                (1.0 + _f(0, 3, omega, vertices_omegas)) +
+            _f(3, 0, omega, vertices_omegas) *
+                _f(2, 0, omega, vertices_omegas) *
+                _f(1, 2, omega, vertices_omegas) *
+                (1.0 + _f(0, 3, omega, vertices_omegas) +
+                 _f(0, 2, omega, vertices_omegas))) /
+           4 / n;
+}
+
+static double _J_21(const double omega, const double vertices_omegas[4]) {
+    double n;
+    n = _n_2(omega, vertices_omegas);
+
+#ifdef THM_EPSILON
+    if (n < THM_EPSILON) {
+        return 0;
+    }
+#endif
+
+    return (_f(3, 1, omega, vertices_omegas) *
+                _f(2, 1, omega, vertices_omegas) *
+                (1.0 + _f(1, 3, omega, vertices_omegas) +
+                 _f(1, 2, omega, vertices_omegas)) +
+            _f(3, 0, omega, vertices_omegas) *
+                _f(1, 3, omega, vertices_omegas) *
+                _f(2, 1, omega, vertices_omegas) *
+                (_f(1, 3, omega, vertices_omegas) +
+                 _f(1, 2, omega, vertices_omegas)) +
+            _f(3, 0, omega, vertices_omegas) *
+                _f(2, 0, omega, vertices_omegas) *
+                _f(1, 2, omega, vertices_omegas) *
+                _f(1, 2, omega, vertices_omegas)) /
+           4 / n;
+}
+
+static double _J_22(const double omega, const double vertices_omegas[4]) {
+    double n;
+    n = _n_2(omega, vertices_omegas);
+
+#ifdef THM_EPSILON
+    if (n < THM_EPSILON) {
+        return 0;
+    }
+#endif
+
+    return (_f(3, 1, omega, vertices_omegas) *
+                _f(2, 1, omega, vertices_omegas) *
+                _f(2, 1, omega, vertices_omegas) +
+            _f(3, 0, omega, vertices_omegas) *
+                _f(1, 3, omega, vertices_omegas) *
+                _f(2, 1, omega, vertices_omegas) *
+                _f(2, 1, omega, vertices_omegas) +
+            _f(3, 0, omega, vertices_omegas) *
+                _f(2, 0, omega, vertices_omegas) *
+                _f(1, 2, omega, vertices_omegas) *
+                (_f(2, 1, omega, vertices_omegas) +
+                 _f(2, 0, omega, vertices_omegas))) /
+           4 / n;
+}
+
+static double _J_23(const double omega, const double vertices_omegas[4]) {
+    double n;
+    n = _n_2(omega, vertices_omegas);
+
+#ifdef THM_EPSILON
+    if (n < THM_EPSILON) {
+        return 0;
+    }
+#endif
+
+    return (_f(3, 1, omega, vertices_omegas) *
+                _f(2, 1, omega, vertices_omegas) *
+                _f(3, 1, omega, vertices_omegas) +
+            _f(3, 0, omega, vertices_omegas) *
+                _f(1, 3, omega, vertices_omegas) *
+                _f(2, 1, omega, vertices_omegas) *
+                (_f(3, 1, omega, vertices_omegas) +
+                 _f(3, 0, omega, vertices_omegas)) +
+            _f(3, 0, omega, vertices_omegas) *
+                _f(2, 0, omega, vertices_omegas) *
+                _f(1, 2, omega, vertices_omegas) *
+                _f(3, 0, omega, vertices_omegas)) /
+           4 / n;
+}
+
+static double _J_30(const double omega, const double vertices_omegas[4]) {
+    double n;
+    n = _n_3(omega, vertices_omegas);
+
+#ifdef THM_EPSILON
+    if (n < THM_EPSILON) {
+        return 0;
+    }
+#endif
+
+    return (1.0 - _f(0, 3, omega, vertices_omegas) *
+                      _f(0, 3, omega, vertices_omegas) *
+                      _f(1, 3, omega, vertices_omegas) *
+                      _f(2, 3, omega, vertices_omegas)) /
+           4 / n;
+}
+
+static double _J_31(const double omega, const double vertices_omegas[4]) {
+    double n;
+    n = _n_3(omega, vertices_omegas);
+
+#ifdef THM_EPSILON
+    if (n < THM_EPSILON) {
+        return 0;
+    }
+#endif
+
+    return (1.0 - _f(0, 3, omega, vertices_omegas) *
+                      _f(1, 3, omega, vertices_omegas) *
+                      _f(1, 3, omega, vertices_omegas) *
+                      _f(2, 3, omega, vertices_omegas)) /
+           4 / n;
+}
+
+static double _J_32(const double omega, const double vertices_omegas[4]) {
+    double n;
+    n = _n_3(omega, vertices_omegas);
+
+#ifdef THM_EPSILON
+    if (n < THM_EPSILON) {
+        return 0;
+    }
+#endif
+
+    return (1.0 - _f(0, 3, omega, vertices_omegas) *
+                      _f(1, 3, omega, vertices_omegas) *
+                      _f(2, 3, omega, vertices_omegas) *
+                      _f(2, 3, omega, vertices_omegas)) /
+           4 / n;
+}
+
+static double _J_33(const double omega, const double vertices_omegas[4]) {
+    double n;
+    n = _n_3(omega, vertices_omegas);
+
+#ifdef THM_EPSILON
+    if (n < THM_EPSILON) {
+        return 0;
+    }
+#endif
+
+    return (1.0 - _f(0, 3, omega, vertices_omegas) *
+                      _f(1, 3, omega, vertices_omegas) *
+                      _f(2, 3, omega, vertices_omegas) *
+                      (1.0 + _f(3, 0, omega, vertices_omegas) +
+                       _f(3, 1, omega, vertices_omegas) +
+                       _f(3, 2, omega, vertices_omegas))) /
+           4 / n;
+}
+
+static double _J_4(void) { return 0.25; }
+
+static double _I_0(void) { return 0.0; }
+
+static double _I_10(const double omega, const double vertices_omegas[4]) {
+    return (_f(0, 1, omega, vertices_omegas) +
+            _f(0, 2, omega, vertices_omegas) +
+            _f(0, 3, omega, vertices_omegas)) /
+           3;
+}
+
+static double _I_11(const double omega, const double vertices_omegas[4]) {
+    return _f(1, 0, omega, vertices_omegas) / 3;
+}
+
+static double _I_12(const double omega, const double vertices_omegas[4]) {
+    return _f(2, 0, omega, vertices_omegas) / 3;
+}
+
+static double _I_13(const double omega, const double vertices_omegas[4]) {
+    return _f(3, 0, omega, vertices_omegas) / 3;
+}
+
+static double _I_20(const double omega, const double vertices_omegas[4]) {
+    double f12_20, g;
+    f12_20 =
+        _f(1, 2, omega, vertices_omegas) * _f(2, 0, omega, vertices_omegas);
+    g = f12_20 +
+        _f(2, 1, omega, vertices_omegas) * _f(1, 3, omega, vertices_omegas);
+
+#ifdef THM_EPSILON
+    if (g < THM_EPSILON) {
+        return 0;
+    }
+#endif
+
+    return (_f(0, 3, omega, vertices_omegas) +
+            _f(0, 2, omega, vertices_omegas) * f12_20 / g) /
+           3;
+}
+
+static double _I_21(const double omega, const double vertices_omegas[4]) {
+    double f13_21, g;
+    f13_21 =
+        _f(1, 3, omega, vertices_omegas) * _f(2, 1, omega, vertices_omegas);
+    g = _f(1, 2, omega, vertices_omegas) * _f(2, 0, omega, vertices_omegas) +
+        f13_21;
+
+#ifdef THM_EPSILON
+    if (g < THM_EPSILON) {
+        return 0;
+    }
+#endif
+
+    return (_f(1, 2, omega, vertices_omegas) +
+            _f(1, 3, omega, vertices_omegas) * f13_21 / g) /
+           3;
+}
+
+static double _I_22(const double omega, const double vertices_omegas[4]) {
+    double f12_20, g;
+    f12_20 =
+        _f(1, 2, omega, vertices_omegas) * _f(2, 0, omega, vertices_omegas);
+    g = f12_20 +
+        _f(2, 1, omega, vertices_omegas) * _f(1, 3, omega, vertices_omegas);
+
+#ifdef THM_EPSILON
+    if (g < THM_EPSILON) {
+        return 0;
+    }
+#endif
+
+    return (_f(2, 1, omega, vertices_omegas) +
+            _f(2, 0, omega, vertices_omegas) * f12_20 / g) /
+           3;
+}
+
+static double _I_23(const double omega, const double vertices_omegas[4]) {
+    double f13_21, g;
+    f13_21 =
+        _f(1, 3, omega, vertices_omegas) * _f(2, 1, omega, vertices_omegas);
+    g = _f(1, 2, omega, vertices_omegas) * _f(2, 0, omega, vertices_omegas) +
+        f13_21;
+
+#ifdef THM_EPSILON
+    if (g < THM_EPSILON) {
+        return 0;
+    }
+#endif
+
+    return (_f(3, 0, omega, vertices_omegas) +
+            _f(3, 1, omega, vertices_omegas) * f13_21 / g) /
+           3;
+}
+
+static double _I_30(const double omega, const double vertices_omegas[4]) {
+    return _f(0, 3, omega, vertices_omegas) / 3;
+}
+
+static double _I_31(const double omega, const double vertices_omegas[4]) {
+    return _f(1, 3, omega, vertices_omegas) / 3;
+}
+
+static double _I_32(const double omega, const double vertices_omegas[4]) {
+    return _f(2, 3, omega, vertices_omegas) / 3;
+}
+
+static double _I_33(const double omega, const double vertices_omegas[4]) {
+    return (_f(3, 0, omega, vertices_omegas) +
+            _f(3, 1, omega, vertices_omegas) +
+            _f(3, 2, omega, vertices_omegas)) /
+           3;
+}
+
+static double _I_4(void) { return 0.0; }

phonopy/source/c/tetrahedron_method.h

@@ -0,0 +1,50 @@
+/* Copyright (C) 2014 Atsushi Togo */
+/* All rights reserved. */
+
+/* This file was originally part of spglib and is part of kspclib. */
+
+/* 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 kspclib 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 __tetrahedron_method_H__
+#define __tetrahedron_method_H__
+
+#include <stddef.h>
+#include <stdint.h>
+
+void thm_get_relative_grid_address(int64_t relative_grid_address[24][4][3],
+                                   const double rec_lattice[3][3]);
+void thm_get_all_relative_grid_address(
+    int64_t relative_grid_address[4][24][4][3]);
+double thm_get_integration_weight(const double omega,
+                                  const double tetrahedra_omegas[24][4],
+                                  const char function);
+int64_t thm_in_tetrahedra(const double f0, const double freq_vertices[24][4]);
+
+#endif

phonopy/source/cmake-format.py

@@ -0,0 +1,4 @@
+with section("format"):
+    disable = False
+    line_width = 85
+    tab_size = 4

phonopy/source/dev-requirements.txt

@@ -0,0 +1 @@
+numpy

phonopy/source/doc/Fleur.rst

@@ -0,0 +1,76 @@
+.. _Fleur_interface:
+
+Fleur & phonopy calculation
+=========================================
+
+Setting up the inpgen file:
+
+The preparation of a Fleur calculation takes two steps. First a basic input file
+is written, that is converted to an inp.xml via the Fleur input generator inpgen.
+
+The input file starts with a comment line describing the calculation. From there,
+a multitude of options can be specified by namelists starting with '&' and ending
+with '/'. Normally, the lattice information would be set preferably by tags like
+'fcc' etc. and the corresponding necessary lattice constants. For further
+information, consult the inpgen documentation under 'User Guide --> Reference -->
+The input generator' on flapw.de.
+
+An important thing to note is:
+The bravais matrix needs to be set directly via the second method proposed in
+the reference. The complete overhead to constuct the bravais matrix from only
+the lattice tag and constants in not (yet) programmed into the phonopy interface.
+The supercell will be written in the same fashion, while the rest of the inpgen
+file is merely copied over.
+
+Also:
+For phonopy to be able to correctly extract the necessary quantities from the
+input file, a mandatory comment '! a1' needs to be put at the end of the first
+line of the Bravais matrix and '! num atoms' after the atom count.
+
+How to run
+----------
+
+A procedure of a Fleur-phonopy calculation may look as follows:
+
+1) Read a Fleur input file and create supercells with the
+   :ref:`Fleur_mode` option::
+
+   % phonopy --fleur -d --dim="a b c" -c fleur_inpgen
+
+   In this example several axbxc supercells are created. ``supercell.in``
+   and ``supercell-XXX.in`` (``XXX`` enumerating the necessary displacements) give
+   the perfect and displaced supercells respectively. ``phonopy_disp.yaml``
+   is also generated. This file contains information on displacements.
+   The supercell files ``supercell-XXX.in`` should be stored in
+   subfolders e.g. ``disp-XXX``, then Fleur calculations are executed
+   in these directories.
+
+2) Calculate forces on atoms in the supercells with displacements.
+   First run the fleur inpgen with the '-f supercell-XXX.in' option
+   The resulting inp.xml is then run by the fleur command itself.
+   After successfull convergence, set the tag 'l_f' in the inp.xml to "T"
+   and add 'f_level="n"' behind it with n from {0,1,2,3}. This optional
+   tag ensures the write-out of the 'FORCES' file and setting it to
+   {1,2,3} calculates additional refined force contibutions.
+
+3) Create ``FORCE_SETS`` by::
+
+     % phonopy --fleur -f disp-001/FORCES disp-002/FORCES ...
+
+   To run this command, ``phonopy_disp.yaml`` has to be located in same
+   directory because the atomic displacements need to be written into the
+   FORCE_SETS file. See some more detail at
+   :ref:`Fleur_force_sets_option`. An example for fcc Al with a 2x2x2
+   supercell and only one necessary displacement is found in
+   ``example/Al-Fleur``.
+
+4) Run the post-process of phonopy with the Fleur input file for the
+   unit cell used in step 1::
+
+   % phonopy --fleur -c fleur_inpgen -p band.conf
+
+   if you prepared a band.conf file or::
+
+   % phonopy --fleur -c fleur_inpgen --dim="2 2 2" [other-OPTIONS] [setting-file]
+
+   if you want to set the path directly or specify a different file.

phonopy/source/doc/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)