diff --git a/README.md b/README.md
index 27559351..08c3883b 100644
--- a/README.md
+++ b/README.md
@@ -1,417 +1,38 @@
+
+
+
+
+
+
+
+
+
+
+## About DeePTB
+
**DeePTB** is a Python package that adopts the deep learning method to construct electronic tight-binding (TB) Hamiltonians using a minimal basis.
-With a neural network environmental correction scheme, **DeePTB** can efficiently predict TB Hamiltonians for large-size unseen structures with *ab initio* accuracy after training with *ab initio* eigenvalues from smaller sizes.
-This feature enables efficient simulations of large-size systems under structural perturbations such as strain, which is crucial for semiconductor band gap engineering. Furthermore, DeePTB offers the ability to perform efficient and accurate finite temperature simulations, incorporating both atomic and electronic behaviour through the integration of molecular dynamics (MD). Another significant advantage is that using eigenvalues as the training labels makes DeePTB much more flexible and independent of the choice of various bases (PW or LCAO) and the exchange-correlation (XC) functionals (LDA, GGA and even HSE) used in preparing the training labels. In addition, **DeePTB** can handle systems with strong spin-orbit coupling (SOC) effects.
+Trained on smaller structures, **DeePTB** can efficiently predict TB Hamiltonians for large-size unseen structures. This feature enables efficient simulations of large-size systems under structural perturbations. Furthermore, DeePTB offers the ability to perform efficient and accurate finite temperature simulations, incorporating both atomic and electronic behavior through the integration of molecular dynamics (MD). Another significant advantage is that **DeePTB** is independent of the choice of various bases (PW or LCAO) and the exchange-correlation (XC) functionals (LDA, GGA, and even HSE) used in preparing the training labels. In addition, **DeePTB** can handle systems with strong spin-orbit coupling (SOC) effects.
These capabilities make **DeePTB** adaptable to various research scenarios, extending its applicability to a wide range of materials and phenomena and offering a powerful and versatile tool for accurate and efficient simulations.
See more details in our DeePTB paper: [arXiv:2307.04638](http://arxiv.org/abs/2307.04638)
-
-In summary, **DeePTB** offers the following key features:
-- Slater-Koster-like parameterization with customizable radial dependence.
-- Orthogonal basis tight-binding Hamiltonian with a customizable number of basis and bond neighbours.
-- Incorporation of local atomic and bond environmental corrections using symmetry-preserving neural networks.
-- Utilization of an efficient gradient-based fitting algorithm based on autograd implementation.
-- Flexibility and independence from the choice of bases and XC functionals used in preparing the training labels.
-- Ability to handle systems with strong spin-orbit coupling effects.
-- Efficient and accurate finite temperature simulations through integration with molecular dynamics.
-
-
-
-
-- [1. **installation**](#1-installation)
- - [**From Source**](#from-source)
- - [**From Pypi**](#from-pypi)
- - [**From Conda**](#from-conda)
-- [2. **Getting Started.**](#2-getting-started)
- - [2.1 **Data**](#21-data)
- - [**Bandinfo**](#bandinfo)
- - [2.2 **input json**](#22-input-json)
- - [2.3 **Training**](#23-training)
- - [2.4 **Testing**](#24-testing)
- - [2.5 **Processing**](#25-processing)
-- [3. **Example: hBN.**](#3-example-hbn)
-- [4. **Gallary**](#4-gallary)
- - [Density of States (DOS)](#density-of-states-dos)
- - [Fermi Surface of Bulk Silicon](#fermi-surface-of-bulk-silicon)
- - [Fermi Velocity of Bulk Silicon](#fermi-velocity-of-bulk-silicon)
- - [Large-scale simulations](#large-scale-simulations)
-
-
-# 1. **installation**
-## **From Source**
-If you are installing from source, you will need:
-
-- Python 3.8 or later
-- torch 1.13.0 or later, following the instruction on [PyTorch: Get Started](https://pytorch.org/get-started/locally) if GPU support is required, otherwise this can be installed with the building procedure.
-- ifermi (optional, install only when 3D fermi-surface plotting is needed.)
-
-First clone or download the source code from the website.
-Then, located in the repository root and running
-
-```bash
-cd path/deeptb
-pip install .
-```
-## **From Pypi**
-
-## **From Conda**
-
-
-
-# 2. **Getting Started.**
-
-## 2.1 **Data**
-The dataset of one structure is recommended to prepare in the following format:
-```
-data/
--- set.x
--- -- eigs.npy # numpy array of shape [num_frame, num_kpoint, num_band]
--- -- kpoints.npy # numpy array of shape [num_kpoint, 3]
--- -- xdat.traj # ase trajectory file with num_frame
--- -- bandinfo.json # defining the training objective of this bandstructure
-```
-One should prepare the **atomic structures** and **electronic band structures**. The **atomic structures** data is in ASE trade binary format, where each structure is stored using an **Atom** class defined in ASE package. The **band structures** data contains the kpoints list and eigenvalues in the binary format of npy. The shape of kpoints data is **[num_kpoint,3]** and eigenvalues is **[num_frame,nk,nbands]**. nsnaps is the number of snapshots, nk is the number of kpoints and nbands is the number of bands.
-
-### **Bandinfo**
-
-`bandinfo.json` defines the settings of the training objective of each structure, basicly you can have specific settings for different structures, which enables flexible training objectives for various structures with different atom numbers and atom types.
-
-The **bandinfo.json** file looks like this:
-```bash
-{
- "band_min": 0,
- "band_max": 4,
- "emin": null, # minimum of fitting energy window
- "emax": null, # maximum of fitting energy window
- "weight": [1] # optional, indicating the weight for each band separately
-}
-```
-**note:** The `0` energy point is located at the lowest energy eigenvalues of the data files, to generalize bandstructure data compute by different DFT packages.
-
-## 2.2 **input json**
-**DeePTB** provides input config templates for quick setup. User can run:
-```bash
-dptb config [-full]
-```
-The template config file will be generated at the path `./input.json`.
-For the full document about the input parameters, we refer to the detail [document](https://deeptb-doc.readthedocs.io/en/latest/index.html). For now, we only need to consider a few vital parameters that can setup the training:
-
-```json
-"common_options": {
- "onsitemode": "none",
- "bond_cutoff": 3.2,
- "atomtype": ["A","B"],
- "proj_atom_anglr_m": {
- "A": ["2s","2p"],
- "B": ["2s","2p"]
- }
-}
-```
-We can get the bond cutoff by `DeePTB`'s bond analysis function, using:
-```bash
-dptb bond [[-c] ] [[-acc] ]
-```
-
-```json
-"model_options": {
- "skfunction": {
- "sk_cutoff": 3.5,
- "sk_decay_w": 0.3,
- }
-}
-```
-
-```json
-"data_options": {
- "use_reference": true,
- "train": {
- "batch_size": 1,
- "path": "./data",
- "prefix": "set"
- },
- "validation": {
- "batch_size": 1,
- "path": "./data",
- "prefix": "set"
- },
- "reference": {
- "batch_size": 1,
- "path": "./data",
- "prefix": "set"
- }
-}
-```
-
-## 2.3 **Training**
-When data and input config file is prepared, we are ready to train the model.
-To train a neural network parameterized Slater-Koster Tight-Binding model (**nnsk**) with Gradient-Based Optimization method, we can run:
-```bash
-dptb train -sk ] [[-i|-r] ]
-```
-For training an environmental dependent Tight-Binding model (**dptb**), the suggested procedure is first to train a **nnsk** model, and use environment dependent neural network as a correction with the command **"-crt"** as proposed in our paper: xxx:
-```bash
-dptb train [[-i|-r] ] [[-o] ]
-```
-
-## 2.4 **Testing**
-After the model is converged, the testing function can be used to do the model test or compute the eigenvalues for other analyses.
-
-Test config is just attained by a little modification of the train config.
-Delete the `train_options` since it is not useful when testing the model. And we delete all lines contained in `data_options`, and add the `test` dataset config:
-```json
-"test": {
- "batch_size": 1,
- "path": "./data", # dataset path
- "prefix": "set" # prefix of the data folder
-}
-```
-if test **nnsk** model, we can run:
-```bash
-dptb test -sk -i [[-o] ]
-```
-if test **dptb** model, we can run:
-```bash
-dptb test -crt -i [[-o] ]
-```
-## 2.5 **Processing**
-**DeePTB** integrates multiple post-processing functionalities in `dptb run` command, including:
-- band structure plotting
-- density of states plotting
-- fermi surface plotting
-- slater-koster parameter transcription
-
-Please see the template config file in `examples/hBN/run/`, and the running command is:
-```bash
-dptb run [-sk] [[-o] ] -i [[-crt] ]
-```
-
-For detailed documents, please see our [Document page](https://deeptb-doc.readthedocs.io/en/latest/index.html).
-
-# 3. **Example: hBN.**
-hBN is a binary compound made of equal numbers of boron (B) and nitrogen (N), we present this as a quick hands-on example. The prepared files are located in:
-```
-deeptb/examples/hBN/
--- data/kpath.0/
--- -- bandinfo.json
--- -- xdat.traj
--- -- kpoints.npy
--- -- eigs.npy
--- run/
--- input_short.json
-```
-The ```input_short.json``` file contains the least number of parameters that are required to start training the **DeePTB** model. ```data``` folder contains the bandstructure data ```kpath.0```, where another important configuration file ```bandinfo.json``` is located.
-
-```bash
-cd deeptb/examples/hBN/data
-# to see the bond length
-dptb bond struct.vasp
-# output:
-Bond Type 1 2 3 4 5
-------------------------------------------------------------------------
- N-N 2.50 4.34 5.01
- N-B 1.45 2.89 3.82 5.21 5.78
- B-B 2.50 4.34 5.01
-```
-Having the data file and input parameter, we can start training our first **DeePTB** model, the first step using the parameters defined in ```input_short.json```:
-Here list some important parameters:
-```json
- "common_options": {
- "onsitemode": "none",
- "bond_cutoff": 1.6,
- }
-
- "proj_atom_anglr_m": {
- "N": [
- "2s",
- "2p"
- ],
- "B": [
- "2s",
- "2p"
- ]
- }
-```
-The ```onsitemode``` is set to ```none``` which means we do not use onsite correction. The ```bond_cutoff``` is set to ```1.6``` which means we use the 1st nearest neighbour for bonding. The ```proj_atom_anglr_m``` is set to ```2s``` and ```2p``` which means we use $s$ and $p$ orbitals as basis.
-
-using the command to train the first model:
-```bash
-cd deeptb/examples/hBN
-dptb train -sk input_short.json -o ./first
-```
-Here ``-sk`` indicate to fit the sk parameters, and ``-o`` indicate the output directory. During the fitting procedure, we can see the loss curve of hBN is decrease consistently. When finished, we get the fitting results in folders ```first```:
-```shell
-first/
-|-- checkpoint
-| |-- best_nnsk_b1.600_c1.600_w0.300.json
-| |-- best_nnsk_b1.600_c1.600_w0.300.pth
-| |-- latest_nnsk_b1.600_c1.600_w0.300.json
-| `-- latest_nnsk_b1.600_c1.600_w0.300.pth
-|-- input_short.json
-|-- log
-| `-- log.txt
-`-- train_config.json
-```
-Here checkpoint saves our fitting files, which best indicate the one in the fitting procedure which has the lowest validation loss. The latest is the most recent results.
-we can plot the fitting bandstructure as:
-```bash
-dptb run -sk band.json -i ./first/checkpoint/best_nnsk_b1.600_c1.600_w0.300.pth -o ./band
-```
-``-i`` states initialize the model from the checkpoint file `./first/checkpoint/best_nnsk_b1.600_c1.600_w0.300.pth`. results will be saved in the directory `band`:
-```
-band/
--- log/
--- -- log.txt
--- results/
--- -- band.png
--- -- bandstructure.npy
-```
-Where `band.png` is the band structure of the trained model. Which looks like this:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
[[-i|-r] ] [[-o] ] [-f]
+```
+To start training, e.p. if starting from the checkpoint `./ckpt/md/2-3-25K_best_nnsk_b5.000_c5.000_w0.100.pth`, we need to run:
+```bash
+dptb train ./ckpt/md/input.json -crt ./ckpt/md/2-3-25K_best_nnsk_b5.000_c5.000_w0.100.pth -o dptb300K -f
+```
+
+`-f` above indicate `--freeze` the `nnsk` model when training the `dptb` model. It is important to use `-f` when one initializes a new `dptb` model (i.e. without `-i/--init-model` or `-r/--restart`).
+
+The only parameter need to be considered here is the `env_cutoff`. It indicates the chemical environment radius that is centred at each atom. To ensure the spatial symmetries of the atom environment and the bond environment embeddings, the `env_cutoff` should be larger than 0.5*`bond_cutoff`.
+
+During the training procedure, the `dptb` model will be saved periodically as checkpoints. If one hasn't frozen the `nnsk` model with `-f`, the trained `nnsk` model will also be saved. Then, we can use the converged model to predict the bandstructure, calculating properties supported by **DeePTB**, or get the predicted Hamiltonian directly. We plot the bandstructure of the converged model on $T=300K$'s MD trajectory for illustration:
+One can run:
+```bash
+dptb run band_md.json -i ./ckpt/md/2-3-300K_best_dptb_b5.000_c5.000_w0.100.pth -crt ./ckpt/md/2-3-300K_best_nnsk_b5.000_c5.000_w0.100.pth -o band
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+