mdkits 0.1.13__py3-none-any.whl → 1.2.3__py3-none-any.whl

mdkits-1.2.3.dist-info/METADATA

@@ -0,0 +1,370 @@
+Metadata-Version: 2.3
+Name: mdkits
+Version: 1.2.3
+Summary: kits for md or dft
+License: MIT
+Keywords: molecular dynamics,density functional theory
+Author: jxxcr
+Author-email: jixxcr@qq.com
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: Cp2kData (>=0.7.2,<0.8.0)
+Requires-Dist: MDAnalysis (>=2.8.0,<3.0.0)
+Requires-Dist: ase (>=3.22.1,<4.0.0)
+Requires-Dist: click (>=8.1.3,<9.0.0)
+Requires-Dist: julia (>=0.6.2,<0.7.0)
+Requires-Dist: matplotlib (>=3.9.0,<4.0.0)
+Requires-Dist: numpy (>=1.26.4,<2.0.0)
+Requires-Dist: pandas (>=2.3.2,<3.0.0)
+Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
+Requires-Dist: tidynamics (>=1.1.2,<2.0.0)
+Project-URL: Repository, https://github.com/jxxcr/mdkits
+Description-Content-Type: text/markdown
+
+# mdkits
+[中文文档](README_zh.md)
+
+`mdkits` provides a variety of tools. Installation script:
+```bash
+pip install mdkits --upgrade
+```
+
+## General Option Parameter Types
+
+1.  `CELL TYPE`: Specifies lattice cell parameters, e.g., `10,10,10`, `10,10,10,90,90,90`, etc.
+2.  `FRAME RANGE`: Specifies the frame range, e.g., `1`, `1:10:2`, etc.
+3.  `--group` and `--surface`: Select analysis objects using [selection language](https://userguide.mdanalysis.org/stable/selections.html).
+4.  `--update_water`, `--distance`, and `--angle`: Enable dynamic update of water molecule positions during trajectory analysis.
+5.  By specifying the `Host` in the corresponding `SSH config-file` on the server as the `ssh_name` environment variable, you can prepend `ssh_name` to the `path` in the script's output, which facilitates subsequent `scp` operations:
+    ```bash
+    ssh_name:path/to/file
+    ```
+
+## Trajectory File Processing Scripts
+
+`md` is the trajectory file processing tool, which includes several processing utilities.
+
+### Density Distribution
+
+`density` is used to analyze the density distribution of a specific element along the z-axis in a system. For example, to analyze the density distribution of the `O` element along the z-axis:
+```bash
+mdkits md density [FILENAME] --group="name H" --cell [FILENAME]
+```
+This will output a file named `density_name_H.dat`, where the first column is the z-axis coordinate and the second column is the density distribution in units of mol/L. To output the density distribution in units of $g/cm^3$, you can specify the `--atomic_mass` option, for example:
+```bash
+mdkits md density [FILENAME] --group="name H" --cell [FILENAME] --atomic_mass=1.00784
+```
+This will output the density distribution in units of $g/cm^3$. You can specify surface atoms to normalize the density distribution to the surface, for example:
+```bash
+mdkits md density [FILENAME] --group="name O" --cell 10,10,10 --atomic_mass=18.01528 --surface="name Pt and name Ru"
+```
+This will normalize the density distribution to the surface and analyze the density distribution of water molecules using the positions of O atoms as the reference for water molecules. For systems with $OH^-$ ions, you can use the `--update_water` option to update the positions of water molecules in each frame, without needing to specify an element explicitly, for example:
+```bash
+mdkits md density [FILENAME] --update_water --cell 10,10,10 --atomic_mass=18.01528 --surface="name Pt and name Ru"
+```
+The output file will be named `density_water.dat`.
+
+### Hydrogen Bonds
+
+`hb` is used to analyze hydrogen bonds in a system, for example, to analyze the distribution of hydrogen bonds along the z-axis:
+```bash
+mdkits md hb [FILENAME] --cell 10,10,40 --surface "prop z < 10" --update_water
+```
+Or to analyze hydrogen bonds of a single water molecule:
+```bash
+mdkits md hb [FILENAME] --cell 10,10,40 --index 15
+```
+
+### Angle
+
+`angle` is used to analyze the abundance distribution of the angle between the bisector vector of a water molecule's OH bond and the surface normal. For example, to analyze the angle abundance distribution of water molecules within 5 Å of the surface:
+```bash
+mdkits md angle [FILENAME] --cell 10,10,40 --surface "name Pt" --water_height 5
+```
+
+### Dipole Distribution
+
+`diople` is used to analyze the dipole ($\cos \phi \rho_{H_2 O}$) distribution in a system. For example, to analyze the $\cos \phi \rho_{H_2 O}$ distribution in the system:
+```bash
+mdkits md diople [FILENAME] --cell 10,10,40 --surface "name Pt"
+```
+
+### Radial Distribution Function (RDF)
+
+`rdf` is used to analyze the radial distribution function between two `group`s. For example, to analyze the radial distribution function between `O` and `H` elements in the system:
+```bash
+mdkits md rdf [FILENAME] --group "name O" "name H" --cell 10,10,40 --range 0.1 5
+```
+
+### Mean Squared Displacement (MSD)
+
+`msd` is used to analyze the mean squared displacement of certain atoms in a system. For example, to analyze the MSD of `Li` atoms along the z-axis:
+```bash
+mdkits md msd [FILENAME] z "name Li"
+```
+
+### Monitor
+
+`monitor` is used to monitor changes in atom height, bond length, and bond angle in a system. For example, to monitor the height of the atom with `index` 0:
+```bash
+mdkits md monitor [FILENAME] --cell 10,10,40 --surface "name Pt" -i 0
+```
+This will output the height from the surface as a function of each frame. To monitor the bond length between atoms 0 and 1:
+```bash
+mdkits md monitor [FILENAME] --cell 10,10,40 --surface "name Pt" -i 0 -i 1
+```
+This will output the heights from the surface for atoms 0 and 1, and the bond length between 0 and 1 as a function of each frame. To monitor the bond angle of 1-0-2:
+```bash
+mdkits md monitor [FILENAME] --cell 10,10,40 --surface "name Pt" -i 1 -i 0 -i 2
+```
+This will output the heights from the surface for atoms 1, 0, and 2, the bond lengths between 1-0 and 0-2, and the bond angle 1-0-2 as a function of each frame. Note that atoms at the vertex of an angle should be placed in the middle.
+
+### Position Normalization
+
+`wrap` is used to normalize the atomic positions in a trajectory file. For example, to normalize the atomic positions in `[FILENAME]` within the unit cell and output it as `wrapped.xyz`. By default, it reads `ABC` and `ALPHA_BETA_GAMMA` information from the `cp2k` output file `input_inp` as lattice cell parameters:
+```bash
+mdkits md wrap [FILENAME]
+```
+Or specify the `cp2k` input file:
+```bash
+mdkits md wrap [FILENAME] --cp2k_input_file setting.inp
+```
+Or specify the lattice cell parameters:
+```bash
+mdkits md wrap [FILENAME] --cell 10,10,10
+```
+The default `[FILENAME]` is `*-pos-1.xyz`.
+
+### Vibrational Density of States (VDOS)
+
+`vac` is used to analyze the velocity autocorrelation function of a trajectory and compute the Fourier transform of the velocity autocorrelation function, which is the vibrational density of states (VDOS). For example, to analyze the VDOS of the system:
+```bash
+mdkits md vac h2o-vel-1.xyz
+```
+The default `[FILENAME]` is `*-vel-1.xyz`.
+
+## DFT Property Analysis Scripts
+
+`dft` is the DFT property analysis tool, which includes several analysis utilities.
+
+### PDOS
+
+`pdos` is used to analyze the PDOS of a system. To analyze the d-orbital DOS of `[FILENAME]`:
+```bash
+mdkits dft pdos [FILENAME] -t d
+```
+
+### CUBE Files
+
+`cube` is used to process files in [`cube` format](https://paulbourke.net/dataformats/cube/), averaging them along the z-axis:
+```bash
+mdkits dft cube [FILENAME]
+```
+The processed data will be output to `cube.out`. You can also calculate the average value within a specific region:
+```bash
+mdkits dft cube [FILENAME] -b 1 2
+```
+This will print the average value to the screen and also record it in the comment line of `cube.out`.
+
+## Modeling
+
+`build` is the modeling tool, which includes several modeling utilities.
+
+### Building Bulk Models
+
+`bulk` is used to build bulk models. For example, to build an `fcc` bulk model of `Pt`:
+```bash
+mdkits build bulk Pt fcc
+```
+To build as a conventional cell model:
+```bash
+mdkits build bulk Pt fcc --cubic
+```
+To build a `Caesium chloride` structure model:
+```bash
+mdkits build bulk CsCl cesiumchloride -a 4.123
+```
+To build a `fluorite` structure model:
+```bash
+mdkits build bulk BaF2 fluorite -a 6.196
+```
+
+### Building Surface Models
+
+`surface` is used to build common surface models. Usage:
+```bash
+mdkits build surface [ELEMENT] [SURFACE_TYPE] [SIZE]
+```
+For example, to build an `fcc111` surface model of `Pt`:
+```bash
+mdkits build surface Pt fcc111 2 2 3 --vacuum 15
+```
+To build a graphene surface:
+```bash
+mdkits build surface C2 graphene 3 3 1 --vacuum 15
+```
+
+### Building Surface Models from Existing Structures
+
+`cut` is used to build surface models from existing structures (the structure must be in a conventional cell). For example, to build an `fcc331` surface model from `Pt_fcc.cif`:
+```bash
+mdkits build cut Pt_fcc.cif --face 3 3 1 --size 3 3 5 --vacuum 15
+```
+
+### Adding Adsorbates to Surface Structures
+
+`adsorbate` is used to add adsorbates to surface structures. For example, to add an `H` atom to `surface.cif`:
+```bash
+mdkits build adsorbate surface.cif H --select "index 0" --height 1    
+```
+Or to add an `H` atom with a coverage of 5 to `Pt_fcc111_335.cif`:
+```bash
+mdkits build adsorbate Pt_fcc111_335.cif H --select "prop z > 16" --height 2 --cover 5
+```
+
+### Building Solution Phase Models
+
+`solution` is used to build solution phase models. When using for the first time, you should install `juliaup`:
+```bash
+mdkits build solution --install_julia
+```
+Then install `Packmol`:
+```bash
+mdkits build solution --install_packmol
+```
+After successful installation, you can use the `solution` functionality. For example, to build a water box with 32 water molecules:
+```bash
+mdkits build solution --water_number 32 --cell 9.86,9.86,9.86
+```
+Or to build a solution containing ions:
+```bash
+mdkits build solution li.xyz k.xyz --water_number 64 --tolerance 2.5 -n 25 -n 45 --cell 15,15,15
+```
+Here, the number of `-n` arguments must match the number of specified solvent molecule types, used to specify the number of solvents to add, respectively. Alternatively, build a solution phase model from `packmol` input files:
+```bash
+mdkits build solution input.pm input2.pm  --infile
+```
+
+### Building Interface Models
+
+`interface` is used to build interface models. For example, to build an interface model without vacuum:
+```bash
+mdkits build interface --slab Pt_fcc100_555.cif --sol water_160.cif
+```
+Or to build an interface with a gas phase model:
+```bash
+mdkits build interface --slab Pt_fcc100_555.cif --sol water_160.cif --cap ne --vacuum 20
+```
+
+### Building Supercell Models
+
+`supercell` is used to build supercell models:
+```bash
+mdkits build supercell Li3PO4.cif 2 2 2
+```
+
+## Others
+
+### Trajectory Extraction
+
+`extract` is used to extract specific frames from a trajectory file. For example, to extract frames from the 1000th to the 2000th frame from `frames.xyz` and output them to `1000-2000.xyz`. The parameters for the `-r` option are consistent with Python's slicing syntax:
+```bash
+mdkits extract frames.xyz -r 1000:2000 -o 1000-2000.xyz
+```
+Or to extract the last frame from the default trajectory file `*-pos-1.xyz` generated by `cp2k` and output it as `frames_-1.xyz` (which is the default behavior of `extract`):
+```bash
+mdkits extract
+```
+Or to output a structure every 50 frames into the `./coord` directory, while adjusting the output format to `cp2k`'s `@INCLUDE coord.xyz` format:
+```bash
+mdkits extract -cr ::50
+```
+To extract the positions of specific elements, for example, to extract the positions of `O` and `H` elements:
+```bash
+mdkits extract --select "name O or name H"
+```
+
+### Structure File Conversion
+
+`convert` is used to convert structure files from one format to another. For example, to convert `structure.xyz` to `out.cif` (default filename is `out`). For files that do not store periodic boundary conditions, you can use the `--cell` option to specify `PBC`:
+```bash
+mdkits convert -c structure.xyz --cell 10,10,10
+```
+To convert `structure.cif` to `POSCAR`:
+```bash
+mdkits convert -v structure.cif
+```
+To convert `structure.cif` to `structure_xyz.xyz`:
+```bash
+mdkits convert -c structure.cif -o structure_xyz
+```
+
+### Data Processing
+
+`data` is used for data processing, such as:
+1.  `--nor`: Normalizes the data.
+2.  `--gaus`: Applies Gaussian filtering to the data.
+3.  `--fold`: Folds and averages stacked data.
+4.  `--err`: Calculates error bars for the data.
+And so on.
+
+### Plotting Tool
+
+`plot` is used for plotting data. `plot` requires reading a YAML format configuration file for plotting. The YAML file format is as follows:
+```yaml
+# plot mode 1
+figure1:
+  data:
+    legend1: ./data1.dat
+    legend2: ./data2.dat
+  x:
+    0: x-axis
+  y:
+    1: y-axis
+  x_range: 
+    - 5
+    - 15
+
+# plot mode 2
+figure2:
+  data:
+    y-xais: ./data.dat
+  x:
+    0: x-axis
+  y:
+    1: legend1
+    2: legend2
+    3: legend3
+    4: legend4
+    5: legend5
+  y_range:
+    - 0.5
+    - 6
+  legend_fontsize: 12
+
+# plot mode error
+12_dp_e_error:
+  data:
+    legend: ./error.dat
+  x:
+    0: x-axis
+  y:
+    1: y-axis
+  fold: dp
+  legend_fontsize: 12
+```
+The above illustrates three plotting modes supported by `plot`: `mode 1`, `mode 2`, and `mode error`. `mode 1` is used for comparing the same column data from multiple data files, `mode 2` is used for comparing different column data from the same data file, and `mode error` is used for plotting mean squared error plots.
+
+`plot` can process multiple YAML files simultaneously. Each YAML file can contain multiple plotting configurations. Plotting configurations for `mode 1` and `mode 2` can be automatically recognized, but the `error` mode requires explicit specification, for example:
+```bash
+mdkits plot *.yaml
+```
+and:
+```bash
+mdkits plot *.yaml --error
+```

mdkits-1.2.3.dist-info/RECORD

@@ -0,0 +1,51 @@
+mdkits/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mdkits/build_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mdkits/build_cli/adsorbate.py,sha256=_Re942ZrHowcsOnBCjRAzkS-eYPWOZEZ5w5PmMztQ7Q,1944
+mdkits/build_cli/build_bulk.py,sha256=5sYnae68bFmo3IAcXFBTi7nJ1hTJKigxuWymRMkNKr8,1622
+mdkits/build_cli/build_cli.py,sha256=sqjnq5aHWLYLbNzN5SORkEYeYaewLagFuSvspJxyh7E,725
+mdkits/build_cli/build_interface.py,sha256=Lknbn2-xs7fTkr2ks-v1fGUFj-2S0DeFNvVkJknBAoc,2743
+mdkits/build_cli/build_solution.py,sha256=7bwaDH-vLBNRzGoYXT72bzLVXdQAZ4HXNuUDuR7AI78,5377
+mdkits/build_cli/build_surface.py,sha256=KBQn8esurXcLFswRVddksot5Jii-jEm-egxq4p1w-DQ,2736
+mdkits/build_cli/cut_surface.py,sha256=_f0t2OyBKb8ZV04b3GezfSDUN4XFd5kQM-yWbSmOofs,2742
+mdkits/build_cli/supercell.py,sha256=ajB0ZbGtq0BFiOqD5ZqqLR7XE4jiINsfIHhshk_EDpo,1031
+mdkits/build_cli/water.xyz,sha256=ByLDz-rYhw_wLPBU78lIQHe4s4Xf5Ckjft-Dus3czIc,171
+mdkits/cli/convert.py,sha256=f0GQQ-hPbJKhMwpITST7sj_LlrCkLdGB4UZY7lpbQsc,1792
+mdkits/cli/data.py,sha256=FGA4S9Cfo6WUJBSPWKOJrrZXHo_Qza-jNG1P_Dw7yi4,3262
+mdkits/cli/extract.py,sha256=33P9DXOUK38ORNZ3f-7Sx-1MCK9J0MIi1mqXHC9Pou0,2945
+mdkits/cli/plot.py,sha256=1yh5dq5jnQDuyWlxV_9g5ztsnuFHVu4ouYQ9VJYSrUU,8938
+mdkits/config/__init__.py,sha256=ZSwmnPK02LxJLMgcYmNb-tIOk8fEuHf5jpqD3SDHWLg,1039
+mdkits/config/settings.yml,sha256=PY7u0PbFLuxSnd54H5tI9oMjUf-mzyADqSZtm99BwG0,71
+mdkits/dft_cli/.back/pdos.py,sha256=EjZ1oWJHHUocZAZe8dgJUu6bkLPVwgrKkggidF3yduE,1445
+mdkits/dft_cli/check_neb.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mdkits/dft_cli/cube.py,sha256=d8S4jdooEul1giK8DAx5yvAFSnSKoV83qd43kw-iSL0,1272
+mdkits/dft_cli/dft_cli.py,sha256=FoibPrWWAw2lKcNBmGa1KgN-kEO7UBa8VmA7cVuYRt8,381
+mdkits/dft_cli/fix.py,sha256=qncb6rsCRdIJtlnIAzR7s3nSG_qv_4X511QV8MGsL0c,1843
+mdkits/dft_cli/pdos.py,sha256=1m1ZJLpOnrxl-oHQLAp0pI26ogxP7W4tgSu8Jh5jGvg,4848
+mdkits/md_cli/angle.py,sha256=EvsW4lmNDM2iyFj8YZcrikGVvYeyP6WIzu269-ZI4iw,5468
+mdkits/md_cli/density.py,sha256=Y2rJU1qJQq3OBb64_-pPhywm7eMdd0ywc8zuuw5XYYs,5392
+mdkits/md_cli/dipole.py,sha256=u_22-vMlzSEqGSpC6c5PG5t3uyjxaRKUvybgytovMk0,5027
+mdkits/md_cli/hb_distribution.py,sha256=lADOBiJYHCHPutXimXVDQpPdRKasBpldhiIl9SKf39o,7950
+mdkits/md_cli/md_cli.py,sha256=2vH04o_3d5kCJsn3qEq-iUPhebKJOrS-e7HJtyiZTiQ,571
+mdkits/md_cli/monitor.py,sha256=JNEgz5RGbFn4x_E85pAiPUY1NVIyZ3b2vjpBk_d1dR8,4536
+mdkits/md_cli/msd.py,sha256=xg_c2sxNDOlxwK8jsNsQ4nbdqQAUvPGhOqFA6TXBTfs,1515
+mdkits/md_cli/rdf.py,sha256=p4HMMYZLfFRPnGx7YHQU6kZnMAfoL6vOyOVpZhfdBfM,1712
+mdkits/md_cli/setting.py,sha256=mxMTYpm6DUjMt9hOKsJbBSKwCqzMilOR0bo1azSdJP0,846
+mdkits/md_cli/vac.py,sha256=MJi_uftl0UUqhWvqDtcr14qtcRgYRd6X0VSg4J5MFN8,2133
+mdkits/md_cli/wrap.py,sha256=dwlLTfSnR5v99QP1klbbzWLXa71uQqprl7nSoVAm9dA,1049
+mdkits/mdkits.py,sha256=EiAt7dxGTaHuuj7bCNxgAqZbX0i3sldO0mBxOG-aMnY,595
+mdkits/util/.fig_operation.py.swp,sha256=iZYqdYMj4UKS1rmbXv8Ve2FcVBcNljX7Y43-neMdPSk,12288
+mdkits/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mdkits/util/arg_type.py,sha256=Gknsv2B9mG-g_q2Qfyh7vytt1wM4UQhFOlicpL4o5TI,2813
+mdkits/util/cp2k_input_parsing.py,sha256=IAZ2fF-s_atiqdrePRkKG1_EQYB195TFdxHUuB3uYtE,1485
+mdkits/util/encapsulated_ase.py,sha256=Be5H08-L3_Uhw4s03Y3CC0ocVH3swcFE8nyCN5yrUgY,4908
+mdkits/util/encapsulated_mda.py,sha256=m3i-XrcscMcM5V7JzLnor3JtAOfuDx3LLMl0tZt0n-w,2325
+mdkits/util/fig_operation.py,sha256=FwffNUtXorMl6qE04FipgzcVljEQii7wrNJUCJMyY3E,1045
+mdkits/util/numpy_geo.py,sha256=B2QVADl1M8iixZrIOre2UUhHqvAeghvM8Q2woEQsH3Q,3880
+mdkits/util/os_operation.py,sha256=MimTPsUMWGuggjxUBYjB86-73K2RdpiJ3EM0z5DQnqg,1091
+mdkits/util/out_err.py,sha256=GvHeXO5xHmTd5DK1QN6zvCSBBOUokM9DFdjsiDifxnc,1094
+mdkits/util/structure_parsing.py,sha256=mRPMJeih3O-ST7HeETDvBEkfV-1psT-XgxyYgDadV0U,4152
+mdkits-1.2.3.dist-info/entry_points.txt,sha256=xoWWZ_yL87S501AzCO2ZjpnVuYkElC6z-8J3tmuIGXQ,44
+mdkits-1.2.3.dist-info/LICENSE,sha256=VLaqyB0r_H7y3hUntfpPWcE3OATTedHWI983htLftcQ,1081
+mdkits-1.2.3.dist-info/METADATA,sha256=ZXYPxpsUV4JvMNC6xfOZmShf-FUZAAuYnep1eLN-Jcw,13858
+mdkits-1.2.3.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+mdkits-1.2.3.dist-info/RECORD,,

mdkits/cli/,hb_distribution_down.py

@@ -1,114 +0,0 @@
-#!/usr/bin/env python3
-
-import numpy as np
-import argparse
-import MDAnalysis
-from MDAnalysis import Universe
-from MDAnalysis.analysis.base import AnalysisBase
-from util import cp2k_input_parsing
-import warnings
-warnings.filterwarnings("ignore")
-
-
-class Hb_distribution(AnalysisBase):
-    def __init__(self, filename, cell, surface, dt=0.001, hb_distance=3.5, hb_angle=35, bin_size=0.2):
-        u = Universe(filename)
-        u.trajectory.ts.dt = dt
-        u.dimensions = cell
-        self.u = u
-        self.atomgroup = u.select_atoms("all")
-        self.hb_distance = hb_distance
-        self.hb_angle = hb_angle
-        self.bin_size = bin_size
-        self.surface = surface
-        self.frame_count = 0
-        super(Hb_distribution, self).__init__(self.atomgroup.universe.trajectory, verbose=True)
-
-    def _prepare(self):
-        bin_num = int(self.u.dimensions[2] / self.bin_size) + 2
-        self.donor = np.zeros(bin_num, dtype=np.float64)
-
-    def _append(self, hb_d):
-        bins_d = np.floor(hb_d / self.bin_size).astype(int) + 1
-
-        bins_d = bins_d[bins_d < len(self.donor)]
-
-        np.add.at(self.donor, bins_d, 1)
-
-        self.frame_count += 1
-
-    def _single_frame(self):
-        o_group = self.atomgroup.select_atoms("name O")
-        o_pair = MDAnalysis.lib.distances.capped_distance(o_group.positions, o_group.positions, min_cutoff=0, max_cutoff=self.hb_distance, box=self.u.dimensions, return_distances=False)
-
-        o0 = o_group[o_pair[:, 0]]
-        o1 = o_group[o_pair[:, 1]]
-
-        o0h1 = self.atomgroup[o0.indices + 1]
-        o0h2 = self.atomgroup[o0.indices + 2]
-
-        angle_o0h1_o0_o1 = np.degrees(
-            MDAnalysis.lib.distances.calc_angles(o0h1.positions, o0.positions, o1.positions, box=self.u.dimensions)
-        )
-        angle_o0h2_o0_o1 = np.degrees(
-            MDAnalysis.lib.distances.calc_angles(o0h2.positions, o0.positions, o1.positions, box=self.u.dimensions)
-        )
-
-        mid_z = (self.surface[0] + self.surface[1]) / 2
-
-        condition_d = ((angle_o0h1_o0_o1 < self.hb_angle) | (angle_o0h2_o0_o1 < self.hb_angle)) & (o0.positions[:, 2] - o1.positions[:, 2] > 0)
-        #condition_d = ((angle_o0h1_o0_o1 < self.hb_angle) | (angle_o0h2_o0_o1 < self.hb_angle)) & (((o0.positions[:, 2] < mid_z) & (o0.positions[:, 2] - o1.positions[:, 2] > 0)) | ((o0.positions[:, 2] > mid_z) & (o0.positions[:, 2] - o1.positions[:, 2] < 0)))
-        #condition_a = ((angle_o1h1_o1_o0 < self.hb_angle) | (angle_o1h2_o1_o0 < self.hb_angle)) & (((o1.positions[:, 2] < mid_z) & (o1.positions[:, 2] - o0.positions[:, 2] > 1.5)) | ((o1.positions[:, 2] > mid_z) & (o1.positions[:, 2] - o0.positions[:, 2] < -1.5)))
-
-        hb_d = (o0.positions[:, 2][condition_d] + o1.positions[:, 2][condition_d]) / 2
-        #hb_a = (o0.positions[:, 2][condition_a] + o1.positions[:, 2][condition_a]) / 2
-
-        self._append(hb_d)
-
-    def _conclude(self):
-        if self.frame_count > 0:
-            average_donor = self.donor / self.frame_count
-
-        bins_z = np.arange(len(self.donor)) * self.bin_size
-
-        lower_z, upper_z = self.surface
-        mask = (bins_z >= lower_z) & (bins_z <= upper_z)
-        filtered_bins_z = bins_z[mask] - lower_z
-        filtered_average_donor = average_donor[mask]
-
-        combined_data = np.column_stack((filtered_bins_z, filtered_average_donor))
-
-        filename = 'hb_distribution_down.dat'
-        np.savetxt(filename, combined_data, header="Z\tDonor", fmt='%.5f', delimiter='\t')
-
-
-def parse_data(s):
-    return [float(x) for x in s.replace(',', ' ').split()]
-
-
-def parse_r(s):
-    return [int(x) for x in s.replace(':', ' ').split()]
-
-
-def parse_argument():
-    parser = argparse.ArgumentParser(description="analysis hb distribution")
-    parser.add_argument('filename', type=str, help='filename to analysis')
-    parser.add_argument('--cp2k_input_file', type=str, help='input file name of cp2k, default is "input.inp"', default='input.inp')
-    parser.add_argument('-r', type=parse_r, help='range of analysis', default=[0, -1, 1])
-    parser.add_argument('--cell', type=parse_data, help='set cell, a list of lattice, --cell x,y,z or x,y,z,a,b,c')
-    parser.add_argument('--surface', type=parse_data, help='[down_surface_z, up_surface_z]')
-    parser.add_argument('--hb_param', type=parse_data, help='[hb_distance, hb_angle], default is [3.5, 35]', default=[3.5, 35])
-
-    return parser.parse_args()
-
-
-def main():
-    args = parse_argument()
-    cell = cp2k_input_parsing.get_cell(args.cp2k_input_file, args.cell)
-
-    hb_dist = Hb_distribution(args.filename, cell, args.surface, hb_distance=args.hb_param[0], hb_angle=args.hb_param[1])
-    hb_dist.run(start=args.r[0], stop=args.r[1], step=args.r[2])
-
-
-if __name__ == '__main__':
-    main()

mdkits/cli/hartree_potential.py

@@ -1,59 +0,0 @@
-#!/usr/bin/env python3
-
-################################################
-# averange cp2k output(or some else file correspond to ase.io.read_cube_data) hartree.cube to z coordinate with python
-## file path is need to pay attention
-## cycle parameter is need to pay attention
-## buck range is need to pay attention
-################################################
-
-from numpy import empty, array, mean, append, concatenate
-from argparse import ArgumentParser
-from util import encapsulated_ase, os_operation
-
-
-def array_type(string):
-	number_list = string.split(',')
-	number_array = array(number_list, dtype=float)
-	return number_array
-
-
-def buck_potential(xaxe, potential, range):
-	mix = concatenate((xaxe.reshape(-1, 1), potential.reshape(-1, 1)), axis=1)
-	mask = (mix[:,0] >= range[0]) & (mix[:,0] <=range[1])
-	buck_potential = mix[mask]
-	ave_potential = mean(buck_potential[:,1])
-	return ave_potential
-
-
-# set argument
-parser = ArgumentParser(description='to handle cp2k output file hartree cube, name should be "hartree-*.cube"')
-parser.add_argument('file_name', type=str, nargs='?', help='hartree cube file', default=os_operation.default_file_name('*-v_hartree-1_*.cube', last=True))
-parser.add_argument('-b', '--buck_range', type=array_type, help='parameter to calculate mean value of buck', default=None)
-parser.add_argument('-o', type=str, help='output file name, default is "out.put"', default='hartree.out')
-
-args = parser.parse_args()
-
-
-## init output potential file's shape, and define a z axe
-init_array = encapsulated_ase.ave_potential(args.file_name)
-potential = empty((0, init_array[0].shape[0]))
-z_coordinates = array((init_array[1])).reshape(-1, 1)
-
-potential = encapsulated_ase.ave_potential(args.file_name)[0]
-
-aved = mean(potential, axis=0)
-total_potential = append(z_coordinates, potential.reshape(-1, 1), axis=1)
-
-## if buck range is exit, out put a difference of potential
-if args.buck_range is not None:
-	buck_potential = buck_potential(z_coordinates, potential, args.buck_range)
-	print(buck_potential)
-	with open('hartree_potential.dat', 'w') as f:
-		f.write(f"{buck_potential}" + '\n')
-
-## write output
-with open(args.o, 'w') as f:
-	for value in total_potential:
-		f.write(" ".join(map(str, value)) + '\n')
-

mdkits/cli/hartree_potential_ave.py

@@ -1,84 +0,0 @@
-#!/usr/bin/env python3
-
-################################################
-# averange cp2k output(or some else file correspond to ase.io.read_cube_data) hartree.cube to z coordinate with python
-## file path is need to pay attention
-## cycle parameter is need to pay attention
-## buck range is need to pay attention
-################################################
-
-from ase.io.cube import read_cube_data
-import numpy as np
-import argparse
-
-def array_type(string):
-	number_list = string.split(',')
-	number_array = np.array(number_list, dtype=int)
-	return number_array
-
-
-def ave_potential(filepath):
-	# is to average hartree file in z_coordinate
-	
-	## read data from filepath
-	data, atoms = read_cube_data(filepath)
-	
-	## define need parameter
-	npoints = data.shape[2]
-	step_size = atoms.cell[2, 2] / ( npoints - 1 )
-	
-	## average hartree file, and calculate z_coordinates
-	z_coordinates = [i * step_size for i in range(npoints)]
-	z_potential = 27.2114 * data[:, :, :].sum(axis=(0, 1)) / ( data.shape[0] * data.shape[1] )
-	return z_potential, z_coordinates
-
-
-def buck_potential(xaxe, potential, range):
-	mix = np.concatenate((xaxe.reshape(-1, 1), potential.reshape(-1, 1)), axis=1)
-	mask = (mix[:,0] >= range[0]) & (mix[:,0] <=range[1])
-	buck_potential = mix[mask]
-	ave_potential = np.mean(buck_potential[:,1])
-	return ave_potential
-
-
-# set argument
-parser = argparse.ArgumentParser(description='to handle cp2k output file hartree cube, name should be "hartree-*.cube"')
-parser.add_argument('folder_path', type=str, help='folder that contain all hartree cube file')
-parser.add_argument('cyc_range', type=array_type, help='cycle parameter, need to seperate with ",", similar with range() -- 1,201  1,201,10')
-parser.add_argument('-b', '--buck_range', type=array_type, help='parameter to calculate mean value of buck', default=None)
-parser.add_argument('-o', type=str, help='output file name, default is "out.put"', default='hartree.out')
-
-args = parser.parse_args()
-
-
-## init output potential file's shape, and define a z axe
-init_array = ave_potential('{}/hartree-{}.cube'.format(args.folder_path, args.cyc_range[0]))
-potential = np.empty((0, init_array[0].shape[0]))
-z_coordinates = np.array((init_array[1])).reshape(-1, 1)
-
-## average one hartree file
-if len(args.cyc_range) == 3:
-	for i in range(args.cyc_range[0], args.cyc_range[1], args.cyc_range[2]):
-		file_path = '{}/hartree-{}.cube'.format(args.folder_path, i)
-		potential = np.append(potential, [ave_potential(file_path)[0]], axis=0)
-else:
-	for i in range(args.cyc_range[0], args.cyc_range[1]):
-		file_path = '{}/hartree-{}.cube'.format(args.folder_path, i)
-		potential = np.append(potential, [ave_potential(file_path)[0]], axis=0)
-
-## average every averaged harterr file, and append to z_coordinates
-#aved_potential = potential[:, :].sum(axis=0) / len(range(1, 201))
-aved = np.mean(potential, axis=0)
-total_potential = np.append(z_coordinates, aved.reshape(-1, 1), axis=1)
-
-## if buck range is exit, out put a difference of potential
-if args.buck_range is not None:
-	buck_potential = buck_potential(z_coordinates, aved, args.buck_range)
-	with open(args.o + 'diff', 'w') as f:
-		f.write("{}\t{}\t{}".format(aved[0], buck_potential, aved[0]-buck_potential))
-
-## write output
-with open(args.o, 'w') as f:
-	for value in total_potential:
-		f.write(" ".join(map(str, value)) + '\n')
-