From a51e0dbf55e388ca5f9f45d0a0579b43a4dbcb15 Mon Sep 17 00:00:00 2001
From: Marcin Kirsz <marcin.kirsz@ed.ac.uk>
Date: Tue, 10 Sep 2024 14:52:18 +0100
Subject: [PATCH 1/5] Update README.md

---
 README.md | 143 ++++++++++++++++++++++++++++++------------------------
 1 file changed, 80 insertions(+), 63 deletions(-)

diff --git a/README.md b/README.md
index 39b863a..7475025 100644
--- a/README.md
+++ b/README.md
@@ -1,93 +1,110 @@
-# MLIP
+```markdown
+# Ta-dah! Documentation
 
+## Introduction
 
+**Ta-dah!** is a modular and fast machine learning software and C++ library specifically designed for interatomic potential development. Written in modern C++, it aims to provide an easy-to-use, modular, and extensible state-of-the-art toolkit.
 
-## Getting started
+Ta-dah! offers a LAMMPS interface compatible with all provided descriptors and models. Users can either operate it from the command line for training models or predictions using pre-existing machine learning potentials or incorporate it as a C++ library for advanced applications.
 
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
+## Why Use Ta-dah!?
 
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
+- **Community Driven**: New ideas are always welcome and implemented if feasible.
+- **Speed**: Accelerates the model development cycle, reducing waiting times significantly.
+- **Continuous Improvement**: Regularly updated with new descriptors, models, bug fixes, and issue resolutions.
+- **Open Source**: Freely available for community use and contribution.
+- **Flexibility**: Combination of various descriptors with different cutoffs and models is supported. Trained models can be tested directly with LAMMPS.
+- **Extensibility**: Easily extendable to include new descriptors, compatible with existing code and LAMMPS interface.
 
-## Add your files
+## Requirements
 
-- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
-- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
+Ta-dah! does not require any external libraries for building or downloading.
 
-```
-cd existing_repo
-git remote add origin https://git.ecdf.ed.ac.uk/tadah/mlip.git
-git branch -M main
-git push -uf origin main
-```
-
-## Integrate with your tools
-
-- [ ] [Set up project integrations](https://git.ecdf.ed.ac.uk/tadah/mlip/-/settings/integrations)
+## Obtaining Ta-dah!
 
-## Collaborate with your team
+The source code is hosted at:
 
-- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
-- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
-- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
-- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
-- [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
+[https://git.ecdf.ed.ac.uk/s1351949/ta-dah](https://git.ecdf.ed.ac.uk/s1351949/ta-dah)
 
-## Test and Deploy
+To download, use git and clone from the stable branch:
 
-Use the built-in continuous integration in GitLab.
-
-- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
-- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
-- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
-- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
-- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
-
-***
+```sh
+git clone -b stable https://git.ecdf.ed.ac.uk/s1351949/ta-dah.git
+```
 
-# Editing this README
+## Installation
 
-When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
+Ta-dah! uses CMake to manage the configuration and compilation process. CMake will determine system-dependent variables based on the `CMakeList.txt` file in the project root directory.
+
+1. Navigate to the project directory:
+   ```sh
+   cd ta-dah
+   ```
+2. Create and navigate to a build directory:
+   ```sh
+   mkdir build && cd build
+   ```
+3. Configure with CMake:
+   ```sh
+   cmake ..
+   ```
+4. Compile and install:
+   ```sh
+   make && make install
+   ```
+
+To change the default library installation location, use the following command instead of `cmake ..`. This is useful when you lack root privileges:
+
+```sh
+cmake .. -DCMAKE_INSTALL_PREFIX=/your/path
+```
 
-## Suggestions for a good README
+## Binary File
 
-Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
+The executable file `ta-dah` will be installed in the `bin` directory within your chosen installation location. On most UNIX systems, the default path is `/usr/local/bin/ta-dah`.
 
-## Name
-Choose a self-explaining name for your project.
+If using the `-DCMAKE_INSTALL_PREFIX=/your/path` flag, the binary file will be located at `/your/path/bin/ta-dah`.
 
-## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
+This concludes the installation process for most users. If you intend to use Ta-dah! as a C++ library, please continue to the next section.
 
-## Badges
-On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
+## Using Ta-dah!
 
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
+To use Ta-dah! from the command line:
 
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
+1. Train models:
+   ```sh
+   ta-dah train -d <descriptor> -m <model> -i <input_file> -o <output_model>
+   ```
+   Replace `<descriptor>`, `<model>`, `<input_file>`, and `<output_model>` with your specific choices.
 
-## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
+2. Use pre-trained models for predictions:
+   ```sh
+   ta-dah predict -m <model_file> -i <input_file> -o <output_file>
+   ```
+   Replace `<model_file>`, `<input_file>`, and `<output_file>` with your specific choices.
 
-## Support
-Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
+For more detailed usage and advanced options, please refer to the official documentation or the help command:
+```sh
+ta-dah --help
+```
 
-## Roadmap
-If you have ideas for releases in the future, it is a good idea to list them in the README.
+## Including Ta-dah! as a C++ Library
 
-## Contributing
-State if you are open to contributions and what your requirements are for accepting them.
+To use Ta-dah! as a C++ library in your project, you can include the necessary headers and link against the Ta-dah! library. Modify your project's CMakeLists.txt to find and link Ta-dah!:
 
-For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
+```cmake
+find_package(TaDah REQUIRED)
+target_link_libraries(your_project_name PRIVATE TaDah)
+```
 
-You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
+Ensure the installation path of Ta-dah! is included in `CMAKE_PREFIX_PATH`:
 
-## Authors and acknowledgment
-Show your appreciation to those who have contributed to the project.
+```sh
+cmake -DCMAKE_PREFIX_PATH=/path/to/ta-dah ..
+```
 
-## License
-For open source projects, say how it is licensed.
+For further instructions and examples, please consult the official Ta-dah! documentation and examples included in the repository.
 
-## Project status
-If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
+---
+For any questions or contributions, please visit the [Ta-dah! repository](https://git.ecdf.ed.ac.uk/s1351949/ta-dah) or submit an issue.
+```
-- 
GitLab


From c72e82271dcffd92cb4d6bcacade8b0e20ba68ca Mon Sep 17 00:00:00 2001
From: Marcin Kirsz <marcin.kirsz@ed.ac.uk>
Date: Tue, 10 Sep 2024 14:53:19 +0100
Subject: [PATCH 2/5] Update README.md

---
 README.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/README.md b/README.md
index 7475025..76d4309 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,3 @@
-```markdown
-# Ta-dah! Documentation
-
 ## Introduction
 
 **Ta-dah!** is a modular and fast machine learning software and C++ library specifically designed for interatomic potential development. Written in modern C++, it aims to provide an easy-to-use, modular, and extensible state-of-the-art toolkit.
-- 
GitLab


From ee0d04b3d20d765a5350b9da7c82c406c2c786fc Mon Sep 17 00:00:00 2001
From: Marcin Kirsz <marcin.kirsz@ed.ac.uk>
Date: Tue, 10 Sep 2024 15:02:36 +0100
Subject: [PATCH 3/5] Update README.md

---
 README.md | 49 ++++++++++++++++++++++++++++++++++---------------
 1 file changed, 34 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index 76d4309..2060a69 100644
--- a/README.md
+++ b/README.md
@@ -1,17 +1,33 @@
 ## Introduction
 
-**Ta-dah!** is a modular and fast machine learning software and C++ library specifically designed for interatomic potential development. Written in modern C++, it aims to provide an easy-to-use, modular, and extensible state-of-the-art toolkit.
+**Ta-dah!** is a fast and modular machine learning software and C++ library specifically designed for developing interatomic potentials. Written in modern C++, it aims to offer an easy-to-use, modular, and extensible state-of-the-art toolkit.
 
-Ta-dah! offers a LAMMPS interface compatible with all provided descriptors and models. Users can either operate it from the command line for training models or predictions using pre-existing machine learning potentials or incorporate it as a C++ library for advanced applications.
+Ta-dah! provides a LAMMPS interface compatible with all supplied descriptors and models. Users can operate it from the command line to train models or make predictions using pre-existing machine learning potentials, or incorporate it as a C++ library for more advanced applications.
+
+## What are Machine Learning Interatomic Potentials?
+
+Machine learning interatomic potentials (MLIPs) are computational models that predict the energy and forces within a system of atoms based on their positions. Traditional potentials often rely on simplified physical models, which can be limited in accuracy and flexibility. In contrast, MLIPs leverage machine learning to learn complex relationships from large datasets of atomic configurations, providing a more accurate and flexible approach to modeling atomic interactions.
+
+### Advantages of MLIPs
+
+- **Accuracy**: Capable of capturing complex physical interactions that traditional potentials might miss.
+- **Efficiency**: Once trained, MLIPs can predict energies and forces much faster than ab initio calculations.
+- **Transferability**: MLIPs can be trained on diverse datasets, making them applicable to a wide range of materials and conditions.
+
+### Applications
+
+- **Materials Science**: Predicting the properties of new materials.
+- **Chemistry**: Modeling reactions and molecular dynamics.
+- **Physics**: Studying condensed matter systems.
 
 ## Why Use Ta-dah!?
 
-- **Community Driven**: New ideas are always welcome and implemented if feasible.
-- **Speed**: Accelerates the model development cycle, reducing waiting times significantly.
+- **Community Driven**: New ideas are always welcomed and implemented if feasible.
+- **Speed**: Accelerates the model development cycle, significantly reducing waiting times.
 - **Continuous Improvement**: Regularly updated with new descriptors, models, bug fixes, and issue resolutions.
 - **Open Source**: Freely available for community use and contribution.
-- **Flexibility**: Combination of various descriptors with different cutoffs and models is supported. Trained models can be tested directly with LAMMPS.
-- **Extensibility**: Easily extendable to include new descriptors, compatible with existing code and LAMMPS interface.
+- **Flexibility**: Supports the combination of various descriptors with different cutoffs and models. Trained models can be tested directly with LAMMPS.
+- **Extensibility**: Easily extendable to include new descriptors, which will be compatible with existing code and the LAMMPS interface.
 
 ## Requirements
 
@@ -21,17 +37,17 @@ Ta-dah! does not require any external libraries for building or downloading.
 
 The source code is hosted at:
 
-[https://git.ecdf.ed.ac.uk/s1351949/ta-dah](https://git.ecdf.ed.ac.uk/s1351949/ta-dah)
+[https://git.ecdf.ed.ac.uk/tadah/](https://git.ecdf.ed.ac.uk/tadah/)
 
 To download, use git and clone from the stable branch:
 
 ```sh
-git clone -b stable https://git.ecdf.ed.ac.uk/s1351949/ta-dah.git
+git clone -b stable https://git.ecdf.ed.ac.uk/tadah/tadah.git
 ```
 
 ## Installation
 
-Ta-dah! uses CMake to manage the configuration and compilation process. CMake will determine system-dependent variables based on the `CMakeList.txt` file in the project root directory.
+Ta-dah! uses CMake to manage the configuration and compilation process. CMake will determine system-dependent variables based on the `CMakeLists.txt` file in the project root directory.
 
 1. Navigate to the project directory:
    ```sh
@@ -50,12 +66,14 @@ Ta-dah! uses CMake to manage the configuration and compilation process. CMake wi
    make && make install
    ```
 
-To change the default library installation location, use the following command instead of `cmake ..`. This is useful when you lack root privileges:
+To change the default library installation location, use the following command instead of `cmake ..`:
 
 ```sh
 cmake .. -DCMAKE_INSTALL_PREFIX=/your/path
 ```
 
+This is useful when you lack root privileges.
+
 ## Binary File
 
 The executable file `ta-dah` will be installed in the `bin` directory within your chosen installation location. On most UNIX systems, the default path is `/usr/local/bin/ta-dah`.
@@ -68,26 +86,27 @@ This concludes the installation process for most users. If you intend to use Ta-
 
 To use Ta-dah! from the command line:
 
-1. Train models:
+1. **Train models:**
    ```sh
    ta-dah train -d <descriptor> -m <model> -i <input_file> -o <output_model>
    ```
    Replace `<descriptor>`, `<model>`, `<input_file>`, and `<output_model>` with your specific choices.
 
-2. Use pre-trained models for predictions:
+2. **Use pre-trained models for predictions:**
    ```sh
    ta-dah predict -m <model_file> -i <input_file> -o <output_file>
    ```
    Replace `<model_file>`, `<input_file>`, and `<output_file>` with your specific choices.
 
 For more detailed usage and advanced options, please refer to the official documentation or the help command:
+
 ```sh
 ta-dah --help
 ```
 
 ## Including Ta-dah! as a C++ Library
 
-To use Ta-dah! as a C++ library in your project, you can include the necessary headers and link against the Ta-dah! library. Modify your project's CMakeLists.txt to find and link Ta-dah!:
+To use Ta-dah! as a C++ library in your project, you can include the necessary headers and link against the Ta-dah! library. Modify your project's `CMakeLists.txt` to find and link Ta-dah!:
 
 ```cmake
 find_package(TaDah REQUIRED)
@@ -103,5 +122,5 @@ cmake -DCMAKE_PREFIX_PATH=/path/to/ta-dah ..
 For further instructions and examples, please consult the official Ta-dah! documentation and examples included in the repository.
 
 ---
-For any questions or contributions, please visit the [Ta-dah! repository](https://git.ecdf.ed.ac.uk/s1351949/ta-dah) or submit an issue.
-```
+
+For any questions, contributions or issues, please visit the [Ta-dah! repository](https://git.ecdf.ed.ac.uk/tadah/).
-- 
GitLab


From 374d33e2b9112eaba9cb60b038d0d5ad54ace6f2 Mon Sep 17 00:00:00 2001
From: Marcin Kirsz <marcin.kirsz@ed.ac.uk>
Date: Tue, 10 Sep 2024 15:08:01 +0100
Subject: [PATCH 4/5] Update README.md

---
 README.md | 127 +-----------------------------------------------------
 1 file changed, 1 insertion(+), 126 deletions(-)

diff --git a/README.md b/README.md
index 2060a69..0e91acf 100644
--- a/README.md
+++ b/README.md
@@ -1,126 +1 @@
-## Introduction
-
-**Ta-dah!** is a fast and modular machine learning software and C++ library specifically designed for developing interatomic potentials. Written in modern C++, it aims to offer an easy-to-use, modular, and extensible state-of-the-art toolkit.
-
-Ta-dah! provides a LAMMPS interface compatible with all supplied descriptors and models. Users can operate it from the command line to train models or make predictions using pre-existing machine learning potentials, or incorporate it as a C++ library for more advanced applications.
-
-## What are Machine Learning Interatomic Potentials?
-
-Machine learning interatomic potentials (MLIPs) are computational models that predict the energy and forces within a system of atoms based on their positions. Traditional potentials often rely on simplified physical models, which can be limited in accuracy and flexibility. In contrast, MLIPs leverage machine learning to learn complex relationships from large datasets of atomic configurations, providing a more accurate and flexible approach to modeling atomic interactions.
-
-### Advantages of MLIPs
-
-- **Accuracy**: Capable of capturing complex physical interactions that traditional potentials might miss.
-- **Efficiency**: Once trained, MLIPs can predict energies and forces much faster than ab initio calculations.
-- **Transferability**: MLIPs can be trained on diverse datasets, making them applicable to a wide range of materials and conditions.
-
-### Applications
-
-- **Materials Science**: Predicting the properties of new materials.
-- **Chemistry**: Modeling reactions and molecular dynamics.
-- **Physics**: Studying condensed matter systems.
-
-## Why Use Ta-dah!?
-
-- **Community Driven**: New ideas are always welcomed and implemented if feasible.
-- **Speed**: Accelerates the model development cycle, significantly reducing waiting times.
-- **Continuous Improvement**: Regularly updated with new descriptors, models, bug fixes, and issue resolutions.
-- **Open Source**: Freely available for community use and contribution.
-- **Flexibility**: Supports the combination of various descriptors with different cutoffs and models. Trained models can be tested directly with LAMMPS.
-- **Extensibility**: Easily extendable to include new descriptors, which will be compatible with existing code and the LAMMPS interface.
-
-## Requirements
-
-Ta-dah! does not require any external libraries for building or downloading.
-
-## Obtaining Ta-dah!
-
-The source code is hosted at:
-
-[https://git.ecdf.ed.ac.uk/tadah/](https://git.ecdf.ed.ac.uk/tadah/)
-
-To download, use git and clone from the stable branch:
-
-```sh
-git clone -b stable https://git.ecdf.ed.ac.uk/tadah/tadah.git
-```
-
-## Installation
-
-Ta-dah! uses CMake to manage the configuration and compilation process. CMake will determine system-dependent variables based on the `CMakeLists.txt` file in the project root directory.
-
-1. Navigate to the project directory:
-   ```sh
-   cd ta-dah
-   ```
-2. Create and navigate to a build directory:
-   ```sh
-   mkdir build && cd build
-   ```
-3. Configure with CMake:
-   ```sh
-   cmake ..
-   ```
-4. Compile and install:
-   ```sh
-   make && make install
-   ```
-
-To change the default library installation location, use the following command instead of `cmake ..`:
-
-```sh
-cmake .. -DCMAKE_INSTALL_PREFIX=/your/path
-```
-
-This is useful when you lack root privileges.
-
-## Binary File
-
-The executable file `ta-dah` will be installed in the `bin` directory within your chosen installation location. On most UNIX systems, the default path is `/usr/local/bin/ta-dah`.
-
-If using the `-DCMAKE_INSTALL_PREFIX=/your/path` flag, the binary file will be located at `/your/path/bin/ta-dah`.
-
-This concludes the installation process for most users. If you intend to use Ta-dah! as a C++ library, please continue to the next section.
-
-## Using Ta-dah!
-
-To use Ta-dah! from the command line:
-
-1. **Train models:**
-   ```sh
-   ta-dah train -d <descriptor> -m <model> -i <input_file> -o <output_model>
-   ```
-   Replace `<descriptor>`, `<model>`, `<input_file>`, and `<output_model>` with your specific choices.
-
-2. **Use pre-trained models for predictions:**
-   ```sh
-   ta-dah predict -m <model_file> -i <input_file> -o <output_file>
-   ```
-   Replace `<model_file>`, `<input_file>`, and `<output_file>` with your specific choices.
-
-For more detailed usage and advanced options, please refer to the official documentation or the help command:
-
-```sh
-ta-dah --help
-```
-
-## Including Ta-dah! as a C++ Library
-
-To use Ta-dah! as a C++ library in your project, you can include the necessary headers and link against the Ta-dah! library. Modify your project's `CMakeLists.txt` to find and link Ta-dah!:
-
-```cmake
-find_package(TaDah REQUIRED)
-target_link_libraries(your_project_name PRIVATE TaDah)
-```
-
-Ensure the installation path of Ta-dah! is included in `CMAKE_PREFIX_PATH`:
-
-```sh
-cmake -DCMAKE_PREFIX_PATH=/path/to/ta-dah ..
-```
-
-For further instructions and examples, please consult the official Ta-dah! documentation and examples included in the repository.
-
----
-
-For any questions, contributions or issues, please visit the [Ta-dah! repository](https://git.ecdf.ed.ac.uk/tadah/).
+Training module
\ No newline at end of file
-- 
GitLab


From a6a2cb638137fd808367dd58f52f84db768759bc Mon Sep 17 00:00:00 2001
From: Marcin Kirsz <marcin.kirsz@ed.ac.uk>
Date: Tue, 17 Sep 2024 10:32:27 +0100
Subject: [PATCH 5/5] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 0e91acf..668426d 100644
--- a/README.md
+++ b/README.md
@@ -1 +1 @@
-Training module
\ No newline at end of file
+# Desktop version of Tadah!MLIP
\ No newline at end of file
-- 
GitLab