aton 0.0.1__py3-none-any.whl

aton/__init__.py

@@ -0,0 +1,13 @@
+"""
+.. include:: ../_README_temp.md
+"""
+
+
+from ._version import __version__ as version
+from . import st
+from . import phys
+from . import txt
+from . import interface
+from . import spx
+from . import qrotor
+

aton/_version.py

@@ -0,0 +1,14 @@
+"""
+# Description
+
+Package version is defined here. Follows semantic versioning, as in:
+
+`vMAJOR.MINOR.PATCH.`
+
+More about semantic versioning:
+https://semver.org/
+
+"""
+
+__version__ = 'v0.0.1'
+

aton/interface/__init__.py

@@ -0,0 +1,78 @@
+"""
+# *Ab-initio* interfaces
+
+This module contains interfaces for several *ab-initio* calculation softwares.
+These interfaces can be easily expanded with the `aton.txt` module.
+
+
+# Index
+
+| | |  
+| --- | --- |  
+| `aton.interface.qe`      | Interface for [Quantum ESPRESSO](https://www.quantum-espresso.org/)'s [pw.x](https://www.quantum-espresso.org/Doc/INPUT_PW.html) module |  
+| `aton.interface.phonopy` | Interface for [Phonopy](https://phonopy.github.io/phonopy/) calculations |  
+| `aton.interface.castep`  | Interface for [CASTEP](https://castep-docs.github.io/castep-docs/) calculations |  
+| `aton.interface.slurm` | Batch jobs via [Slurm](https://slurm.schedmd.com/) |
+
+
+# Examples
+
+## Quantum ESPRESSO
+
+To read the output from a Quantum ESPRESSO pw.x calculation,  
+```python
+from aton.interface import qe
+# Read to a dictionary
+calculation = qe.read_out('relax.out')
+calculation.keys()  # See the available values
+# Final energy from the calculation
+energy = calculation['Energy']
+```
+
+To modify values from an input file,  
+```python
+from aton.interface import qe
+# Add a hydrogen atom to a specific position
+qe.add_atom('H  0.10  0.20  0.30')
+# Set the input ecutwfc value
+qe.set_value('relax.in', 'ecutwfc', 60.0)
+```
+
+Check the full `aton.interface.qe` API reference for more details.
+
+
+## Phonopy
+
+To perform a phonon calculation from a relaxed structure via Quantum ESPRESSO,  
+```python
+from aton import interface
+# Create the supercell inputs
+interface.phonopy.make_supercells(dimension='2 2 2')
+# Sbatch to a cluster
+interface.slurm.sbatch('supercell-', 'template.slurm')
+```
+
+Check the full `aton.interface.phonopy` API reference for more details.
+
+
+## CASTEP
+
+To read output values from a CASTEP calculation,  
+```python
+from aton.interface import castep
+# Read the output
+output = castep.read_castep('calculation.castep')
+# Get the final energy
+energy = output['Energy']
+```
+
+Check the full `aton.interface.castep` API reference for more details.
+
+"""
+
+
+from . import qe
+from . import phonopy
+from . import castep
+from . import slurm
+

aton/interface/castep.py

@@ -0,0 +1,93 @@
+"""
+# Description
+
+Functions to work with [CASTEP](https://castep-docs.github.io/castep-docs/) calculation files.
+
+# Index
+
+| | |
+| --- | --- |
+| `read_castep()` | Output reading |
+
+---
+"""
+
+
+import aton.st.file as file
+import aton.txt.find as find
+import aton.txt.extract as extract
+
+
+def read_castep(filename) -> dict:
+    """
+    Reads a CASTEP output file, specified in `filename`.
+    Returns a dictionary with the following keys:
+    `'Enthalpy'` (LBFGS: Final Enthalpy, in kJ/mol),
+    `'Energy'` (Total energy corrected for finite basis set, in eV),
+    `'Space group'`, `'Volume'` (Angstrom^3), `'Density'` (amu/Angstrom^3), `'Density_g'` (g/cm^3),
+    `'A'`, `'B'`, `'C'` (Angstroms), `'Alpha'`, `'Beta'`, `'Gamma'` (Degrees).\n
+    Note that these output keys start with a **C**apital letter.
+    """
+    file_castep = file.get(filename)
+    # Initial definitions
+    enthalpy    = None
+    energy      = None
+    space_group = None
+    volume      = None
+    density     = None
+    density_g   = None
+    a           = None
+    b           = None
+    c           = None
+    alpha       = None
+    beta        = None
+    gamma       = None
+    # Find the output values in the file
+    enthalpy_str    = find.lines(file_castep, 'LBFGS: Final Enthalpy     =', -1)
+    energy_str      = find.lines(file_castep, 'Total energy corrected for finite basis set =', -1)
+    space_group_str = find.lines(file_castep, 'Space group of crystal =', -1)
+    volume_str      = find.lines(file_castep, 'Current cell volume =', -1)
+    density_str     = find.lines(file_castep, 'density =', -1, 1)
+    a_str           = find.lines(file_castep, 'a =', -1)
+    b_str           = find.lines(file_castep, 'b =', -1)
+    c_str           = find.lines(file_castep, 'c =', -1)
+    
+    if enthalpy_str:
+        enthalpy = extract.number(enthalpy_str[0], 'LBFGS: Final Enthalpy')
+    if energy_str:
+        energy = extract.number(energy_str[0], 'Total energy corrected for finite basis set')
+    if space_group_str:
+        # Avoid little stupid errors
+        space_group_str = space_group_str.replace(',','.')
+        space_group = extract.string(space_group_str[0], 'Space group of crystal')
+    if volume_str:
+        volume = extract.number(volume_str[0], 'Current cell volume')
+    if density_str:
+        density = extract.number(density_str[0], 'density')
+        density_g = extract.number(density_str[1], '')
+    if a:
+        a = extract.number(a_str, 'a')
+        alpha = extract.number(a_str, 'alpha')
+    if b:
+        b = extract.number(b_str, 'b')
+        beta = extract.number(b_str, 'beta')
+    if c:
+        c = extract.number(c_str, 'c')
+        gamma = extract.number(c_str, 'gamma')
+    # Return as a dict
+    dictionary = {
+        'Enthalpy'    : enthalpy,
+        'Energy'      : energy,
+        'Space group' : space_group,
+        'Volume'      : volume,
+        'Density'     : density,
+        'Density_g'   : density_g,
+        'A'           : a,
+        'B'           : b,
+        'C'           : c,
+        'Alpha'       : alpha,
+        'Beta'        : beta,
+        'Gamma'       : gamma,
+    }
+    return dictionary
+

aton/interface/phonopy.py

@@ -0,0 +1,152 @@
+"""
+# Description
+
+Functions to work with [Phonopy](https://phonopy.github.io/phonopy/) calculations,
+along with [Quantum ESPRESSO](https://www.quantum-espresso.org/).  
+
+
+# Index
+
+| | |
+| --- | --- |
+| `make_supercells()` | Build supercell SCF inputs for phonon calculations |
+
+
+# Examples
+
+To create the supercells and run the phonon calculations
+from a folder with `relax.in` and `relax.out` files,
+using a `template.slurm` file,
+```python
+from aton import interface
+interface.phonopy.make_supercells()
+interface.slurm.sbatch('supercell-', 'scf.slurm')
+```
+
+---
+"""
+
+
+import os
+import re
+from aton._version import __version__
+import aton.st.file as file
+import aton.st.call as call
+import aton.txt.find as find
+import aton.txt.edit as edit # text
+import aton.txt.extract as extract
+import aton.interface.qe as qe
+import aton.interface.slurm as slurm
+
+
+def make_supercells(
+        dimension:str='2 2 2',
+        relax_in:str='relax.in',
+        relax_out:str='relax.out',
+        folder:str=None,
+        slurm_template:str=None,
+    ) -> None:
+    """
+    Creates the supercell inputs of a given `dimension` ('2 2 2' by default),
+    from the `relax_in` and `relax_out` files in the `folder`
+    ('relax.in', 'relax.out' and CWD by default, respectively),
+    needed for the Phonopy calculations with Quantum ESPRESSO.
+
+    If `slurm_template` is present,
+    it checks it with `aton.interface.slurm.check_template()`.
+    """
+    print(f'\nWelcome to thotpy.phonopy {__version__}\n'
+          'Creating all supercell inputs with Phonopy for Quantum ESPRESSO...\n')
+    qe.scf_from_relax(folder, relax_in, relax_out)
+    _supercells_from_scf(dimension, folder)
+    _copy_scf_header_to_supercells(folder)
+    print('\n------------------------------------------------------\n'
+          'PLEASE CHECH BELOW THE CONTENT OF THE supercell-001.in\n'
+          '------------------------------------------------------\n')
+    call.bash('head -n 100 supercell-001.in')
+    print('\n------------------------------------------------------\n'
+          'PLEASE CHECH THE CONTENT OF THE supercell-001.in\n'
+          'The first 100 lines of the input were printed above!\n'
+          '------------------------------------------------------\n\n'
+          'If it seems correct, run the calculations with thotpy.phonopy.sbatch()\n')
+    if slurm_template:
+        slurm.check_template(slurm_template, folder)
+    return None
+
+
+def _supercells_from_scf(
+        dimension:str='2 2 2',
+        folder:str=None,
+        scf:str='scf.in'
+    ) -> None:
+    """
+    Creates supercells of a given `dimension` (`2 2 2` by default) inside a `folder`,
+    from a Quantum ESPRESSO `scf` input (`scf.in` by default).
+    """
+    print(f'\naton.interface.phonopy {__version__}\n')
+    folder = call.here(folder)
+    scf_in = file.get(folder, scf, True)
+    if scf_in is None:
+        raise ValueError('No SCF input found in path!')
+    call.bash(f'phonopy --qe -d --dim="{dimension}" -c {scf_in}')
+    return None
+
+
+def _copy_scf_header_to_supercells(
+        folder:str=None,
+        scf:str='scf.in',
+    ) -> None:
+    """Paste the header from the `scf` file in `folder` to the supercells created by Phonopy."""
+    print(f'\naton.interface.phonopy {__version__}\n'
+          f'Adding headers to Phonopy supercells for Quantum ESPRESSO...\n')
+    folder = call.here(folder)
+    # Check if the header file, the scf.in, exists
+    scf_file = file.get(folder, scf, True)
+    if scf_file is None:
+        raise ValueError('No header file found in path!')
+    # Check if the supercells exist
+    supercells = file.get_list(folder, 'supercell-')
+    if supercells is None:
+        raise ValueError('No supercells found in path!')
+    # Check if the supercells contains '&CONTROL' and abort if so
+    supercell_sample = supercells[0]
+    is_control = find.lines(supercell_sample, r'(&CONTROL|&control)', 1, 0, False, True)
+    if is_control:
+        raise ValueError('Supercells already contain &CONTROL! Did you do this already?')
+    # Check if the keyword is in the scf file
+    is_header = find.lines(scf_file, r'ATOMIC_SPECIES', 1, 0, False, False)
+    if not is_header:
+        raise ValueError('No ATOMIC_SPECIES found in header!')
+    # Copy the scf to a temp file
+    temp_scf = '_scf_temp.in'
+    file.copy(scf_file, temp_scf)
+    # Remove the top content from the temp file
+    edit.delete_under(temp_scf, 'K_POINTS', -1, 2, False)
+    # Find the new number of atoms and replace the line
+    updated_values = find.lines(supercell_sample, 'ibrav', 1)  # !    ibrav = 0, nat = 384, ntyp = 5
+    if not updated_values:
+        print("!!! Okay listen, this is weird. This code should never be running, "
+              "but for some reson we couldn't find the updated values in the supercells. "
+              "Please, introduce the NEW NUMBER OF ATOMS in the supercells manually (int):")
+        nat = int(input('nat = '))
+    else:
+        nat = extract.number(updated_values[0], 'nat')
+    qe.set_value(temp_scf, 'nat', nat)
+    # Remove the lattice parameters, since Phonopy already indicates units
+    qe.set_value(temp_scf, 'celldm(1)', '')
+    qe.set_value(temp_scf, 'A', '')
+    qe.set_value(temp_scf, 'B', '')
+    qe.set_value(temp_scf, 'C', '')
+    qe.set_value(temp_scf, 'cosAB', '')
+    qe.set_value(temp_scf, 'cosAC', '')
+    qe.set_value(temp_scf, 'cosBC', '')
+    # Add the header to the supercells
+    with open(temp_scf, 'r') as f:
+        header = f.read()
+    for supercell in supercells:
+        edit.insert_at(supercell, header, 0)
+    # Remove the temp file
+    os.remove('_scf_temp.in')
+    print('Done!')
+    return None
+