yu-mcal 0.1.0__py3-none-any.whl

mcal/utils/gaus_log_reader.py

@@ -0,0 +1,91 @@
+"""Gaussian log file reader (2025/06/21)"""
+import os
+from pathlib import Path
+
+
+def check_normal_termination(log_file: str) -> bool:
+    """Check if the calculation terminated normally.
+
+    Parameters
+    ----------
+    log_file : str
+        Path to the log file
+
+    Returns
+    -------
+    bool
+        True if the calculation terminated normally, False otherwise
+    """
+    if not Path(log_file).exists():
+        return False
+
+    with FileReader(log_file) as f:
+        line = f.reversed_readline()
+        if 'Normal termination' in line:
+            return True
+        else:
+            return False
+
+
+class FileReader:
+    """File reader that reads line by line from the end.
+
+    Examples
+    --------
+    >>> with FileReader('sample.txt') as f:
+    ...     while True:
+    ...         line = f.reversed_readline()
+    ...         if not line:
+    ...             break
+    ...         print(line)
+    """
+    def __init__(self, file_path, buffer_size=8192):
+        self.buffer_size = buffer_size
+        self.file = open(file_path, 'rb')
+        # ファイルポインタをファイルの末尾に移動
+        self.file.seek(0, os.SEEK_END)
+        self.file_size = self.file.tell()
+        # 最後のブロックの終了位置をファイルサイズに設定
+        self.reversed_block_end = self.file_size
+        # 最後のブロックの開始位置を計算（ファイル末尾からバッファサイズ分前、またはファイル先頭）
+        self.reversed_block_start = max(0, self.reversed_block_end - self.buffer_size)
+        self.lines = []
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+    def close(self):
+        self.file.close()
+
+    def reversed_readline(self):
+        if not self.lines and self.reversed_block_end - self.reversed_block_start != 0:
+            # ファイルポインタを現在のブロックの開始位置に設定
+            self.file.seek(self.reversed_block_start)
+
+            block = self.file.read(self.reversed_block_end - self.reversed_block_start)
+            lines = block.splitlines(keepends=True)
+
+            # 現在のブロックがファイルの最初のブロックの場合
+            if self.reversed_block_start == 0:
+                # ブロックの終了位置を開始位置に設定して次の読み取りを防ぐ
+                self.reversed_block_end = self.reversed_block_start
+            else:
+                # 次のブロックの終了位置を更新(現在のブロックの最初の行の長さを加算)
+                self.reversed_block_end = max(0, self.reversed_block_start + len(lines[0]))
+
+            self.reversed_block_start = max(0, self.reversed_block_end - self.buffer_size)
+
+            # 末尾のブロックの場合、全行を読み取る
+            if self.reversed_block_end == 0:
+                self.lines = lines
+            else:
+                self.lines = lines[1:]
+
+            return self.lines.pop().decode('utf-8')
+        elif self.lines:
+            return self.lines.pop().decode('utf-8')
+        else:
+            return None

mcal/utils/gjf_maker.py

@@ -0,0 +1,267 @@
+""" GjfMaker beta (2025/08/18)"""
+import os
+import warnings
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+import pandas as pd
+
+
+class GjfMaker:
+    parent_dir = Path(os.path.abspath(__file__)).parent.parent
+    ELEMENT_PROP = pd.read_csv(f'{parent_dir}/constants/element_properties.csv')
+    ELEMENTS_NUM = ELEMENT_PROP[['symbol', 'number']].set_index('symbol').to_dict()['number']
+
+    def __init__(self, remove_radical_flag: bool = False) -> None:
+        """Initialize the GjfMaker class.
+
+        Parameters
+        ----------
+        remove_radical_flag : bool
+            If True, the radical is removed, by default False.
+            Not recommended to use this flag.
+        """
+        self.remove_radical_flag = remove_radical_flag
+
+        self._link_dict = {}
+        self._link_num = 0
+        self._cpu_num = '%NProcShared=9\n'
+        self._mem_num = '%Mem=40GB\n'
+        self._is_chk_file = False
+        self._is_rwf_file = False
+        self.is_detail = False
+        self._function = '# B3LYP/6-31G(d,p)\n'
+        self._root = []
+        self._title = '\nDefalut Title\n'
+        self._symbols = []
+        self._charge_spin = ''
+        self._coordinates = []
+
+        self._root_space = ' '
+
+    def add_link(self) -> None:
+        """Add the link of the gjf file."""
+        self.create_chk_file()
+        self._link_dict[self._link_num] = [self._cpu_num, self._mem_num, self._function, self._root]
+        self._link_num += 1
+        self._root = ['Geom=AllCheck\n', 'Guess=Read\n']
+
+    def add_root(self, root: str) -> None:
+        """Add the root of the gjf file."""
+        if root[0] == '#':
+            root = root[1:]
+        self._root.append(root + '\n')
+
+    def create_chk_file(self) -> None:
+        """Create the chk file."""
+        self._is_chk_file = True
+
+    def create_rwf_file(self) -> None:
+        """Create the rwf file."""
+        self._is_rwf_file = True
+
+    def export_gjf(
+        self,
+        file_name: str,
+        save_dir: str = '.',
+        chk_rwf_name: Optional[str] = None
+    ) -> None:
+        """Export the gjf file.
+
+        Parameters
+        ----------
+        file_name : str
+            Name of the gjf file.
+        save_dir : str
+            Directory to save the gjf file.
+        chk_rwf_name : Optional[str]
+            Name of the chk or rwf file.
+        """
+        if self.remove_radical_flag and self._check_radical():
+            print('This molecule is radical')
+            return
+
+        os.makedirs(save_dir, exist_ok=True)
+
+        self._link_dict[self._link_num] = [self._cpu_num, self._mem_num, self._function, self._root]
+
+        if self._is_chk_file:
+            if chk_rwf_name:
+                self._chk_file = f'%Chk={chk_rwf_name}.chk\n'
+            else:
+                self._chk_file = f'%Chk={save_dir}/{file_name}.chk\n'
+        else:
+            self._chk_file = ''
+
+        if self._is_rwf_file:
+            if chk_rwf_name:
+                self._rwf_file = f'%RWF={chk_rwf_name}.rwf\n'
+            else:
+                self._rwf_file = f'%RWF={save_dir}/{file_name}.rwf\n'
+        else:
+            self._rwf_file = ''
+
+        with open(f'{save_dir}/{file_name}.gjf', 'w') as f:
+            for i in range(self._link_num+1):
+                _cpn_num, _mem_num, _function, _root = self._link_dict[i]
+                if i > 0:
+                    f.write(f'\n--Link{i}--\n')
+                f.write(_cpn_num)
+                f.write(_mem_num)
+                f.write(self._chk_file)
+                f.write(self._rwf_file)
+                f.write(_function)
+                for r in _root:
+                    f.write(f'#{self._root_space}{r}')
+
+                if i == 0:
+                    f.write(self._title)
+
+                    if not self._charge_spin:
+                        self._check_charge_spin()
+                    f.write(self._charge_spin)
+
+                    for sym, (x, y, z) in zip(self._symbols, self._coordinates):
+                        x = f'{x:.8f}'.rjust(14, ' ')
+                        y = f'{y:.8f}'.rjust(14, ' ')
+                        z = f'{z:.8f}'.rjust(14, ' ')
+                        f.write(f' {sym}     {x} {y} {z}\n')
+            f.write('\n')
+
+    def opt(self, tight: bool = True) -> None:
+        """Set the optimization option of the gjf file.
+
+        Parameters
+        ----------
+        tight : bool
+            If True, the optimization is tight, by default True.
+        """
+        opt = 'Opt'
+        if tight:
+            opt = 'Opt=Tight'
+        self.add_root(opt)
+
+    def output_detail(self) -> None:
+        """Output the detail to log file."""
+        self.is_detail = True
+        _, function = self._function.split()
+        self._function = f'#P {function}\n'
+        self._root_space = '  '
+
+    def reset_variable(self) -> None:
+        """Reset the variables of the gjf file."""
+        self._root = []
+        self._symbols = []
+        self._coordinates = []
+        self._link_dict = {}
+        self._link_num = 0
+
+    def set_charge_spin(self, charge: int, spin: int) -> None:
+        """Set the charge and spin of the molecule.
+
+        Parameters
+        ----------
+        charge : int
+            Charge of the molecule.
+        spin : int
+            Spin of the molecule.
+        """
+        self._charge_spin = f'\n{charge} {spin}\n'
+
+    def set_coordinates(self, coordinates: List[Tuple[float, float, float]]) -> None:
+        """Set the coordinates of the molecule.
+
+        Parameters
+        ----------
+        coordinates : List[Tuple[float, float, float]]
+            Coordinates of the molecule.
+        """
+        self._coordinates.extend(coordinates)
+
+    def set_function(self, function: str) -> None:
+        """Set the function of the gjf file.
+
+        Parameters
+        ----------
+        function : str
+            Function of the gjf file.
+        """
+        detail = ''
+        if self.is_detail:
+            detail = 'P'
+
+        self._function = f'#{detail} {function}\n'
+
+    def set_resource(self, cpu_num: int, mem_num: int, mem_unit: str = 'GB') -> None:
+        """Set the number of cpu and memory.
+
+        Parameters
+        ----------
+        cpu_num : int
+            Number of cpu.
+        mem_num : int
+            Number of memory.
+        mem_unit : str
+            Unit of memory, by default 'GB'.
+        """
+        self._cpu_num = f'%NProcShared={cpu_num}\n'
+        self._mem_num = f'%Mem={mem_num}{mem_unit}\n'
+
+    def set_symbols(self, symbols: List[str]) -> None:
+        """Set the symbols of the molecule.
+
+        Parameters
+        ----------
+        symbols : List[str]
+            Symbols of the molecule.
+        """
+        self._symbols.extend(symbols)
+
+    def set_title(self, title: str) -> None:
+        """Set the title of the gjf file.
+
+        Parameters
+        ----------
+        title : str
+            Title of the gjf file.
+        """
+        self._title = f'\n{title}\n'
+
+    def _check_charge_spin(self) -> None:
+        """Check the charge and spin of the molecule."""
+        elements = 0
+
+        if not self._symbols:
+            self._charge_spin = ''
+            return
+
+        for symbol in self._symbols:
+            elements += self.ELEMENTS_NUM[symbol]
+
+        if elements % 2 == 0:
+            self._charge_spin = '\n0 1\n'
+        else:
+            self._charge_spin = '\n0 2\n'
+
+    def _check_radical(self) -> bool:
+        """Check if the molecule is radical.
+
+        Returns
+        -------
+        bool
+            True if the molecule is radical, False otherwise.
+
+        Warnings
+        --------
+        This radical check is incomplete. If the number of unpaired electrons is even, it is not considered a radical.
+        """
+        # FIXME: This radical check is incomplete. If the number of unpaired electrons is even, it is not considered a radical.
+        warnings.warn('This radical check is incomplete. If the number of unpaired electrons is even, it is not considered a radical.')
+        elements = 0
+        for symbol in self._symbols:
+            elements += self.ELEMENTS_NUM[symbol]
+
+        if elements % 2 == 0:
+            return False
+        else:
+            return True

yu_mcal-0.1.0.dist-info/METADATA

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: yu-mcal
+Version: 0.1.0
+Summary: Program for the calculation of mobility tensor for organic semiconductor crystals
+Author: Koki Ozawa
+Author-email: Hiroyuki Matsui <h-matsui@yz.yamagata-u.ac.jp>
+License: MIT License
+        
+        Copyright (c) 2025 Hiroyuki Matsui
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: mobility,mobility tensor,organic semiconductor,reorganization energy,transfer integral
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Requires-Dist: numpy>=2.0.2
+Requires-Dist: pandas>=2.3.3
+Description-Content-Type: text/markdown
+
+# mcal: Program for the calculation of mobility tensor for organic semiconductor crystals
+[![Python](https://img.shields.io/badge/python-3.9%20or%20newer-blue)](https://www.python.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+# Overview
+`mcal.py` is a tool for calculating mobility tensors of organic semiconductors. It calculates transfer integrals and reorganization energy from crystal structures, and determines mobility tensors considering anisotropy and path continuity.
+
+# Requirements
+* Python 3.9 or newer
+* NumPy
+* Pandas
+* Gaussian 09 or 16
+
+# Important notice
+* The path of the Gaussian must be set.
+
+# Installation
+```bash
+pip install yu-mcal
+```
+
+
+## Verify Installation
+
+After installation, you can verify by running:
+
+```bash
+mcal --help
+```
+
+# mcal Usage Manual
+
+## Basic Usage
+
+```bash
+mcal <cif_filename or pkl_filenname> <osc_type> [options]
+```
+
+### Required Arguments
+
+- `cif_filename`: Path to the CIF file
+- `pkl_filename`: Path to the pickle file
+- `osc_type`: Organic semiconductor type
+  - `p`: p-type semiconductor (uses HOMO level)
+  - `n`: n-type semiconductor (uses LUMO level)
+
+### Basic Examples
+
+```bash
+# Calculate as p-type semiconductor
+mcal xxx.cif p
+
+# Calculate as n-type semiconductor
+mcal xxx.cif n
+```
+
+## Options
+
+### Calculation Settings
+
+#### `-M, --method <method>`
+Specify the calculation method used in Gaussian calculations.
+- **Default**: `B3LYP/6-31G(d,p)`
+- **Example**: `mcal xxx.cif p -M "B3LYP/6-31G(d)"`
+
+#### `-c, --cpu <number>`
+Specify the number of CPUs to use.
+- **Default**: `4`
+- **Example**: `mcal xxx.cif p -c 8`
+
+#### `-m, --mem <memory>`
+Specify the amount of memory in GB.
+- **Default**: `10`
+- **Example**: `mcal xxx.cif p -m 16`
+
+#### `-g, --g09`
+Use Gaussian 09 (default is Gaussian 16).
+- **Example**: `mcal xxx.cif p -g`
+
+### Calculation Control
+
+#### `-r, --read`
+Read results from existing log files without executing Gaussian.
+- **Example**: `mcal xxx.cif p -r`
+
+#### `-rp, --read_pickle`
+Read results from existing pickle file without executing calculations.
+- **Example**: `mcal xxx_result.pkl p -rp`
+
+#### `--resume`
+Resume calculation using existing results if log files terminated normally.
+- **Example**: `mcal xxx.cif p --resume`
+
+#### `--fullcal`
+Disable speedup processing using moment of inertia and distance between centers of weight, and calculate transfer integrals for all pairs.
+- **Example**: `mcal xxx.cif p --fullcal`
+
+#### `--cellsize <number>`
+Specify the number of unit cells to expand in each direction around the central unit cell for transfer integral calculations.
+- **Default**: `2` (creates 5×5×5 supercell)
+- **Examples**: 
+  - `mcal xxx.cif p --cellsize 1` (creates 3×3×3 supercell)
+  - `mcal xxx.cif p --cellsize 3` (creates 7×7×7 supercell)
+
+### Output Settings
+
+#### `-p, --pickle`
+Save calculation results to a pickle file.
+- **Example**: `mcal xxx.cif p -p`
+
+### Diffusion Coefficient Calculation Methods
+
+#### `--mc`
+Calculate diffusion coefficient tensor using kinetic Monte Carlo method.
+- **Example**: `mcal xxx.cif p --mc`
+
+#### `--ode`
+Calculate diffusion coefficient tensor using Ordinary Differential Equation method.
+- **Example**: `mcal xxx.cif p --ode`
+
+## Practical Usage Examples
+
+### Basic Calculations
+```bash
+# Calculate mobility of p-type xxx
+mcal xxx.cif p
+
+# Use 8 CPUs and 16GB memory
+mcal xxx.cif p -c 8 -m 16
+```
+
+### High-Precision Calculations
+```bash
+# Calculate transfer integrals for all pairs (high precision, time-consuming)
+mcal xxx.cif p --fullcal
+
+# Use larger supercell to widen transfer integral calculation range
+mcal xxx.cif p --cellsize 3
+
+# Use different basis set
+mcal xxx.cif p -M "B3LYP/6-311G(d,p)"
+```
+
+### Reusing Results
+```bash
+# Read from existing calculation results
+mcal xxx.cif p -r
+
+# Read from existing pickle file
+mcal xxx_result.pkl p -rp
+
+# Resume interrupted calculation
+mcal xxx.cif p --resume
+
+# Save results to pickle file
+mcal xxx.cif p -p
+```
+
+### Comparing Diffusion Coefficients
+```bash
+# Compare with normal calculation + kinetic Monte Carlo + ODE methods
+mcal xxx.cif p --mc --ode
+```
+
+## Output
+
+### Standard Output
+- Reorganization energy
+- Transfer integrals for each pair
+- Diffusion coefficient tensor
+- Mobility tensor
+- Eigenvalues and eigenvectors of mobility
+
+## Notes
+
+1. **Calculation Time**: Calculation time varies significantly depending on the number of molecules and cell size
+2. **Memory Usage**: Ensure sufficient memory for large systems
+3. **Gaussian Installation**: Gaussian 09 or Gaussian 16 is required
+4. **Dependencies**: Make sure all required Python libraries are installed
+
+## Troubleshooting
+
+### If calculation stops midway
+```bash
+# Resume with --resume option
+mcal xxx.cif p --resume
+```
+
+### Memory shortage error
+```bash
+# Increase memory amount
+mcal xxx.cif p -m 32
+```
+
+### To reduce calculation time
+```bash
+# Enable speedup processing (default)
+mcal xxx.cif p
+
+# Use smaller supercell for faster calculation
+mcal xxx.cif p --cellsize 1
+
+# Increase number of CPUs
+mcal xxx.cif p -c 16
+``` 
+
+# Authors
+[Matsui Laboratory, Research Center for Organic Electronics (ROEL), Yamagata University](https://matsui-lab.yz.yamagata-u.ac.jp/index-e.html)  
+Hiroyuki Matsui, Koki Ozawa  
+Email: h-matsui[at]yz.yamagata-u.ac.jp  
+Please replace [at] with @  

yu_mcal-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+mcal/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+mcal/mcal.py,sha256=eL57d_vm8Rf0kAZwVgRphRvIpEB9_u1NaBSPUs_wvlI,28648
+mcal/calculations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcal/calculations/hopping_mobility_model.py,sha256=kjE_07nC4hbhWV5B37G0rtsgPqjBuHP0wsJ53rXoPOQ,13180
+mcal/calculations/rcal.py,sha256=CH3iV18KTM8xU7M7zKR3e1m67GbJLH8zi0j50TsUXLE,13500
+mcal/calculations/tcal.py,sha256=td09qG28PGDOxY_lQDwKk0W0iReh8RF6_dd3kjN62QE,39979
+mcal/constants/element_properties.csv,sha256=_Yanl713VZQaAqPYoLNn-hXDdg01ZfkYsCLQ1SQSX8w,4073
+mcal/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcal/utils/cif_reader.py,sha256=nhvk7y8ix4yKhyKjDaw2Luotw6YFMGbGCaeBVP6Qd5E,22901
+mcal/utils/gaus_log_reader.py,sha256=nNIgBae9hRUgpmNF7eIC5LOENSo6NQmuckMM4A3HAa8,3159
+mcal/utils/gjf_maker.py,sha256=Kkh_gNcifFfhTikZar6SzoNJ7AyEBiCBXJTQkHxHX-0,8193
+yu_mcal-0.1.0.dist-info/METADATA,sha256=oBAS8ZHFduaZrGTw-O9-reJlUGEn-VJNPxbl4iQvS7E,7630
+yu_mcal-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+yu_mcal-0.1.0.dist-info/entry_points.txt,sha256=_0xZR3t9qvFSd9L6Iot03NixVLxXioEY19L6w3Fs1Ew,40
+yu_mcal-0.1.0.dist-info/licenses/LICENSE,sha256=JP8vm7gYE73jLgnMFTOLNo_RnH88RrB4Goyh7H_muto,1072
+yu_mcal-0.1.0.dist-info/RECORD,,

yu_mcal-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

yu_mcal-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcal = mcal.mcal:main

yu_mcal-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hiroyuki Matsui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.