Skip to content
Snippets Groups Projects
Commit a51e0dbf authored by Marcin Kirsz's avatar Marcin Kirsz
Browse files

Update README.md

parent 5eedf23e
No related branches found
No related tags found
2 merge requests!4Main,!1Main
Pipeline #42276 passed
Stage: build.debug
    Stage: run.unit.tests
      Stage: build.release
        Stage: run.functional.tests
          Stage: build.examples
            Stage: run.examples
              Hide whitespace changes
              Inline Side-by-side
              Showing
              with 80 additions and 63 deletions
              README.md
              + 80
              − 63
              View file @ a51e0dbf
              # 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.
              ```
              0% or .
              You are about to add 0 people to the discussion. Proceed with caution.
              Finish editing this message first!
              Please register or to comment