### Run eOn Example (Bash)

Source: https://github.com/theochemui/eon/blob/main/docs/source/tutorials/CECAM_LTS_MAP_2024/troubleshooting.md

Navigates to an example directory and executes the eOn server using Python. This snippet demonstrates how to start the eOn server and shows typical output messages during initialization and job processing.

```bash
cd examples/akmc-al
python -m eon.server
Eon version None
State list path does not exist; Creating: .//states/
Registering results
Processed 0 results
Queue contains 0 searches
Making 8 process searches
Job finished: .//jobs/scratch/0_0
Job finished: .//jobs/scratch/0_1
Job finished: .//jobs/scratch/0_2
```

--------------------------------

### Setup Environment with Pixi and Meson

Source: https://github.com/theochemui/eon/blob/main/client/potentials/Metatomic/readme.org

This snippet demonstrates how to set up the environment using pixi and then configure, build, and install metatomic using meson. It specifies build options such as release type, library directory, and enables metatomic and torch integration. Dependencies are managed via pip.

```nushell
pixi s -e metatomic # or dev-mta
(meson setup --reconfigure bbdir
        --prefix=($env.CONDA_PREFIX)
        --buildtype release --libdir=lib
        -Dpip_metatomic=True
        -Dwith_metatomic=True
        -Dtorch_version=2.9
)
meson install -C bbdir
```

--------------------------------

### Build eOn with Performance Optimizations (ccache/mold)

Source: https://github.com/theochemui/eon/blob/main/docs/source/install/index.md

Configures the meson build with optional performance enhancements using ccache and mold. These are specified via native files during the meson setup.

```bash
# With ccache installed, add --native-file nativeFiles/ccache_gnu.ini
# With mold installed, add --native-file nativeFiles/mold.ini
```

--------------------------------

### Install eOn using Conda/Pixi

Source: https://github.com/theochemui/eon/blob/main/docs/source/install/index.md

Installs the eOn package using either pixi or conda/micromamba. Pixi is recommended for managing environments and dependencies. This is the simplest way to get started with eOn.

```bash
# best with pixi
pixi init
pixi add eon
# or with conda/micromamba
micromamba install -c conda-forge eon
```

--------------------------------

### Build eOn from Source using Meson

Source: https://context7.com/theochemui/eon/llms.txt

Guide to building the eOn software from its source code using the meson build system. Covers cloning the repository, setting up the development environment, configuring the build with optional features, and installing the software.

```bash
# Clone repository
git clone https://github.com/TheochemUI/eOn.git
cd eOn

# Enter development environment
pixi shell
# Or use specific environment
pixi s -e dev-lite

# Configure and build with meson
meson setup bbdir --prefix=$CONDA_PREFIX --libdir=lib --buildtype=release
meson install -C bbdir

# Enable optional features during build
meson setup bbdir --prefix=$CONDA_PREFIX --libdir=lib -Dwith_lammps=true -Dwith_serve=true
```

--------------------------------

### Configure and Install eOn with Meson

Source: https://github.com/theochemui/eon/blob/main/docs/source/install/index.md

Sets up and installs eOn using the meson build system. It specifies the installation prefix and library directory. This method is part of the source build process.

```bash
# conda-compilers may try to install to
# $CONDA_PREFIX/lib/x86_64-linux-gnu
# without --libdir
meson setup bbdir --prefix=$CONDA_PREFIX --libdir=lib --buildtype=release
meson install -C bbdir
```

--------------------------------

### Build QUIP from Source

Source: https://github.com/theochemui/eon/blob/main/docs/source/user_guide/quip.md

Clones the quip-nix repository, then clones the QUIP source code recursively. It compiles QUIP with SOAP support and installs it as a library. It also sets up necessary environment variables like QUIP_ARCH and QUIP_LIB_DIR_BLD.

```bash
git clone https://github.com/HaoZeke/quip-nix.git
cd quip-nix
git clone --recursive https://github.com/libAtoms/QUIP.git QUIP
cd QUIP/src
git clone --recursive https://github.com/mcaroba/turbogap.git
source ./../setEnvVars.sh
mkdir -p build/$QUIP_ARCH
mkdir -p "$QUIP_STRUCTS_DIR"
cp ../files/$QUIP_ARCH-Makefile.inc build/$QUIP_ARCH/Makefile.inc
export EXTRA_LINKOPTS="$(pkg-config --libs openblas)"
make -j1
make libquip
make install
cd build/linux_x86_64_gfortran/
export QUIP_LIB_DIR_BLD=$(pwd)
```

--------------------------------

### Build and Install eonclient

Source: https://github.com/theochemui/eon/blob/main/docs/source/devdocs/benchmarks.md

Builds and installs the eonclient binary using Meson. This is a prerequisite for running ASV benchmarks locally and is also performed in the CI workflow.

```bash
meson setup builddir --prefix=$CONDA_PREFIX --libdir=lib --buildtype release
meson install -C builddir
```

--------------------------------

### Install and Verify Eon Library Path (Bash)

Source: https://github.com/theochemui/eon/blob/main/Deprecated_Docs.org

This snippet demonstrates how to install the Eon library using meson and verify its installation path. It then shows how to add the library's directory to the LD_LIBRARY_PATH environment variable to resolve potential linking issues.

```bash
meson install -C bbdir | grep libeon
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/micromamba/envs/eongit/lib
```

--------------------------------

### Clone eOn Repository

Source: https://github.com/theochemui/eon/blob/main/docs/source/install/index.md

Clones the eOn source code from its GitHub repository. This is the first step for building eOn from source. Ensure you have git installed.

```bash
git clone https://github.com/TheochemUI/eOn.git
cd Eon
```

--------------------------------

### Run eonclient with a Configuration File

Source: https://context7.com/theochemui/eon/llms.txt

Launches eonclient using a configuration file for detailed setup, including model serving and potential parameters. This allows for complex and reproducible simulation setups.

```bash
eonclient --serve "metatomic:12345" --config model.ini
```

--------------------------------

### Build and Install Project with Pixi and Meson

Source: https://github.com/theochemui/eon/blob/main/Readme.org

Configures, builds, and installs the project using Meson within a pixi environment. It first attempts to set up the build directory with specific options and then installs the built artifacts. The `--prefix` and `--libdir` ensure correct installation paths within the Conda environment.

```bash
pixi run bash -c "meson setup bbdir \
  --prefix=$CONDA_PREFIX --libdir=lib \
  --buildtype release --wipe 2>/dev/null \
  || meson setup bbdir --prefix=$CONDA_PREFIX \
  --libdir=lib --buildtype release"
pixi run meson install -C bbdir
```

--------------------------------

### Add New Benchmark Class in Python

Source: https://github.com/theochemui/eon/blob/main/docs/source/devdocs/benchmarks.md

Example of how to define a new benchmark class in Python for ASV. It includes methods for setup, teardown, timing (`time_`), and peak memory measurement (`peakmem_`).

```python
class TimeMyBenchmark:
    """Short description of what this benchmarks."""

    timeout = 120
    repeat = 5
    number = 1
    warmup_time = 0

    def setup(self):
        self.tmpdir = tempfile.mkdtemp(prefix="asv_eon_")
        _copy_data(BENCH_DATA / "my_benchmark", self.tmpdir)

    def teardown(self):
        shutil.rmtree(self.tmpdir, ignore_errors=True)

    def time_my_benchmark(self):
        """Wall-clock time."""
        subprocess.run(
            ["eonclient"],
            cwd=self.tmpdir,
            check=True,
            capture_output=True,
        )

    def peakmem_my_benchmark(self):
        """Peak memory."""
        subprocess.run(
            ["eonclient"],
            cwd=self.tmpdir,
            check=True,
            capture_output=True,
        )
```

--------------------------------

### Build eOn with LAMMPS Support

Source: https://github.com/theochemui/eon/blob/main/docs/source/user_guide/quip.md

Clones the eOn repository and links the built LAMMPS shared libraries into the client/potentials/LAMMPS directory. It then configures and installs eOn using Meson, enabling LAMMPS support with '-Dwith_lammps=True'. This allows eOn to use LAMMPS potentials.

```bash
gh repo clone theochemui/eon
cd eOn
ln -sf $LMP_BLD_DIR/liblammps* "./client/potentials/LAMMPS/"
meson setup bbdir --prefix=$CONDA_PREFIX --libdir=lib -Dwith_lammps=True --buildtype=release
meson install -C bbdir
```

--------------------------------

### Install eOn using Conda/Mamba or Pixi

Source: https://context7.com/theochemui/eon/llms.txt

Instructions for installing the eOn software package using either the conda/mamba package manager or the pixi package manager. Includes commands to verify the installation by running a single point calculation.

```bash
# Install with micromamba (recommended)
micromamba install -c conda-forge eon

# Or with pixi
pixi init
pixi add eon

# Verify installation - run a single point calculation with Lennard-Jones potential
eonclient -s molecule.con -p lj

# Run server for aKMC simulations
python -m eon.server
```

--------------------------------

### Install CatLearnPot Target with CMake

Source: https://github.com/theochemui/eon/blob/main/client/potentials/CatLearnPot/CMakeLists.txt

Installs the CatLearnPot target. This command makes the built library available for use in other projects or for deployment. It typically places the library files in standard installation locations.

```cmake
install(TARGETS CatLearnPot)
```

--------------------------------

### Install Dependencies with Pixi

Source: https://github.com/theochemui/eon/blob/main/Readme.org

Installs project dependencies using the pixi package manager. This command ensures a reproducible build environment by fetching and setting up all necessary libraries and tools.

```bash
pixi install
```

--------------------------------

### Run eOn with MPI Communicator in Bash

Source: https://github.com/theochemui/eon/blob/main/docs/source/user_guide/communicator.md

Bash script example for running eOn using the MPI communicator. It sets environment variables for the number of clients and the server path, then executes the MPI-aware client binary. This requires a specially compiled MPI client and is currently only supported for AKMC.

```bash
#!/bin/bash
export eOn_NUMBER_OF_CLIENTS=7
export eOn_SERVER_PATH=~/eon/akmc.py
mpirun -n 8 ~/eon/client/eonclientmpi
```

--------------------------------

### Install GPRPotential Library Target with CMake

Source: https://github.com/theochemui/eon/blob/main/client/potentials/GPRPotential/CMakeLists.txt

This CMake command installs the GPRPotential target, making the built library available for use in other projects or for deployment. The 'install' command ensures that the compiled library is placed in the appropriate location according to the CMake installation rules.

```cmake
install(TARGETS GPRPotential)
```

--------------------------------

### Install QSC Library

Source: https://github.com/theochemui/eon/blob/main/client/potentials/QSC/CMakeLists.txt

Installs the QSC target (the shared library) to the appropriate location based on the CMake installation rules. This makes the library available for use in other projects or for deployment.

```cmake
install(TARGETS QSC)
```

--------------------------------

### Manual Installation using CMake for Metatensor and Metatomic

Source: https://github.com/theochemui/eon/blob/main/client/potentials/Metatomic/readme.org

This section details the manual installation process for metatensor and metatomic using cmake and ninja. It highlights the complexity due to cargo usage within cmake for header generation and emphasizes building directly into the CONDA_PREFIX. It includes specific cmake configurations for metatensor-torch and metatomic, specifying the build directory, installation prefix, and torch directory.

```nushell
# For metatensor and metensor-torch
(cmake -G Ninja
       -B build -DBUILD_METATENSOR_TORCH=ON
       -DTorch_DIR="/home/rgoswami/Git/Github/Cpp/cppShit/materials/differentiation/torchTrials/libtorch/share/cmake/Torch/"
       -DCMAKE_INSTALL_PREFIX=$"($env.CONDA_PREFIX)")
cmake --build build
cmake --install build
# For metatomic
(cmake -G Ninja
        -B build
        -DTorch_DIR="/home/rgoswami/Git/Github/Cpp/cppShit/materials/differentiation/torchTrials/libtorch/share/cmake/Torch/"
        -DCMAKE_INSTALL_PREFIX=$"($env.CONDA_PREFIX)")
 cmake --build build
 cmake --install build
```

--------------------------------

### Set up Base Environment with Conda

Source: https://github.com/theochemui/eon/blob/main/docs/source/user_guide/quip.md

Creates and activates a new conda environment named 'quip_eon_lammps'. It then installs essential packages like eigen, numpy, ase, PyYAML, pytest, sphinx, meson, gh, cmake, subversion, pkgconfig, and openblas. Finally, it sets the PYTHONROOT environment variable to the conda prefix.

```bash
micromamba create -n quip_eon_lammps
micromamba activate quip_eon_lammps
micromamba install -c conda-forge eigen numpy ase PyYAML pytest sh pytest-datadir sphinx meson gh cmake subversion pkgconfig openblas
export PYTHONROOT=$CONDA_PREFIX
```

--------------------------------

### Run eOn Server for Simulation (Bash)

Source: https://github.com/theochemui/eon/blob/main/docs/source/tutorials/parrep.md

This command initiates the eOn simulation server. It starts the simulation process and begins registering results.

```bash
python -m eon.server

```

--------------------------------

### Install Target: Morse (CMake)

Source: https://github.com/theochemui/eon/blob/main/client/potentials/Morse/CMakeLists.txt

Installs the 'Morse' target. This command makes the built 'Morse' library available for use in other projects or for deployment.

```cmake
install(TARGETS Morse)
```

--------------------------------

### Parallel Replica Dynamics Example: Dictionary vs INI Configuration

Source: https://github.com/theochemui/eon/blob/main/docs/source/tutorials/dict_config.md

Presents side-by-side examples of Parallel Replica Dynamics configuration, one using a Python dictionary and the other a traditional INI file. The Python script generates the INI file, which is then used to run the simulation.

```python
from pathlib import Path
from rgpycrumbs.eon.helpers import write_eon_config

settings = {
    "Main": {
        "job": "parallel-replica",
        "temperature": 300,
    },
    "Potential": {
        "potential": "morse_al",
    },
    "Parallel Replica": {
        "num_replicas": 4,
        "num_steps": 1000,
    },
    "Optimizer": {
        "converged_force": 0.001,
        "max_iterations": 1000,
    },
    "Communicator": {
        "type": "local",
        "number_of_CPUs": 2,
        "num_jobs": 2,
    },
}

write_eon_config(Path("../../examples/parallel-replica"), settings)
```

```ini
[Main]
job = parallel-replica
temperature = 300

[Potential]
potential = morse_al

[Parallel Replica]
num_replicas = 4
num_steps = 1000

[Optimizer]
converged_force = 0.001
max_iterations = 1000

[Communicator]
type = local
number_of_CPUs = 2
num_jobs = 2
```

--------------------------------

### Basin Hopping Example: Dictionary vs INI Configuration

Source: https://github.com/theochemui/eon/blob/main/docs/source/tutorials/dict_config.md

Presents side-by-side examples of Basin Hopping configuration, one using a Python dictionary and the other a traditional INI file. The Python script generates the INI file, which is then used to run the simulation.

```python
from pathlib import Path
from rgpycrumbs.eon.helpers import write_eon_config

settings = {
    "Main": {
        "job": "basin-hopping",
        "temperature": 300,
    },
    "Potential": {
        "potential": "morse_al",
    },
    "Basin Hopping": {
        "num_steps": 1000,
        "step_size": 0.1,
    },
    "Optimizer": {
        "converged_force": 0.001,
        "max_iterations": 1000,
    },
    "Communicator": {
        "type": "local",
        "number_of_CPUs": 2,
        "num_jobs": 2,
    },
}

write_eon_config(Path("../../examples/basin-hopping"), settings)
```

```ini
[Main]
job = basin-hopping
temperature = 300

[Potential]
potential = morse_al

[Basin Hopping]
num_steps = 1000
step_size = 0.1

[Optimizer]
converged_force = 0.001
max_iterations = 1000

[Communicator]
type = local
number_of_CPUs = 2
num_jobs = 2
```

--------------------------------

### AKMC Example: Dictionary vs INI Configuration

Source: https://github.com/theochemui/eon/blob/main/docs/source/tutorials/dict_config.md

Presents side-by-side examples of AKMC configuration, one using a Python dictionary and the other a traditional INI file. The Python script generates the INI file, which is then used to run the simulation.

```python
from pathlib import Path
from rgpycrumbs.eon.helpers import write_eon_config

settings = {
    "Main": {
        "job": "akmc",
        "temperature": 300,
    },
    "Potential": {
        "potential": "morse_pt",
    },
    "Optimizer": {
        "converged_force": 0.001,
        "max_iterations": 1000,
    },
    "AKMC": {
        "confidence": 0.95,
    },
    "Process Search": {
        "minimize_first": True,
    },
    "Communicator": {
        "type": "local",
        "number_of_CPUs": 2,
        "num_jobs": 2,
    },
    "Saddle Search": {
        "displace_least_coordinated_weight": 1.0,
        "displace_radius": 3.3,
        "displace_magnitude": 0.1,
        "min_mode_method": "dimer",
        "max_energy": 10.0,
    },
}

write_eon_config(Path("../../examples/akmc-pt"), settings)
```

```ini
[Main]
job = akmc
temperature = 300

[Potential]
potential = morse_pt

[Optimizer]
converged_force = 0.001
max_iterations = 1000

[AKMC]
confidence = 0.95

[Process Search]
minimize_first = True

[Communicator]
type = local
number_of_CPUs = 2
num_jobs = 2

[Saddle Search]
displace_least_coordinated_weight = 1.0
displace_radius = 3.3
displace_magnitude = 0.1
min_mode_method = dimer
max_energy = 10.0
```

--------------------------------

### NEB Example: Dictionary vs INI Configuration

Source: https://github.com/theochemui/eon/blob/main/docs/source/tutorials/dict_config.md

Presents side-by-side examples of NEB (Nudged Elastic Band) configuration, one using a Python dictionary and the other a traditional INI file. The Python script generates the INI file, which is then used to run the simulation.

```python
from pathlib import Path
from rgpycrumbs.eon.helpers import write_eon_config

settings = {
    "Main": {
        "job": "neb",
        "temperature": 300,
    },
    "Potential": {
        "potential": "morse_al",
    },
    "NEB": {
        "num_images": 10,
        "climb": True,
    },
    "Optimizer": {
        "converged_force": 0.001,
        "max_iterations": 1000,
    },
    "Communicator": {
        "type": "local",
        "number_of_CPUs": 2,
        "num_jobs": 2,
    },
}

write_eon_config(Path("../../examples/neb-al"), settings)
```

```ini
[Main]
job = neb
temperature = 300

[Potential]
potential = morse_al

[NEB]
num_images = 10
climb = True

[Optimizer]
converged_force = 0.001
max_iterations = 1000

[Communicator]
type = local
number_of_CPUs = 2
num_jobs = 2
```

--------------------------------

### Build eOn from Source using Pixi

Source: https://github.com/theochemui/eon/blob/main/docs/source/install/index.md

Enters a pixi development shell or a specific development environment for building eOn. This approach handles dependencies using conda-lock.

```bash
pixi shell
# or
pixi s -e dev-lite
```

--------------------------------

### Run ASV Benchmarks Locally

Source: https://github.com/theochemui/eon/blob/main/docs/source/devdocs/benchmarks.md

Installs ASV, configures the machine, and runs the eonclient benchmarks. The `--quick` flag runs each benchmark once; omitting it enables full statistical sampling. It also shows how to compare results between commits using asv-spyglass.

```bash
pip install asv
asv machine --yes
asv run -E "existing:$(which python)" --set-commit-hash $(git rev-parse HEAD) --quick
```

--------------------------------

### Configure Local Communicator in TOML

Source: https://github.com/theochemui/eon/blob/main/docs/source/user_guide/communicator.md

Example TOML configuration for the local communicator in eOn. It specifies the communicator type as 'local', the path to the client binary, and the number of CPUs to utilize. This setup is for running jobs directly on the server.

```toml
[Communicator]
type = "local"
client_path = "eonclient-custom"
number_of_cpus = 8
```

--------------------------------

### Connect to eon RPC Server with ChemGP

Source: https://github.com/theochemui/eon/blob/main/docs/source/user_guide/serve_mode.md

Demonstrates how to connect to a running eonclient server using ChemGP's RpcPotential. It shows how to initialize the potential and perform calculations, as well as how to use it as an optimization oracle.

```julia
using ChemGP

# Connect to a running eonclient --serve instance
pot = RpcPotential("localhost", 12345, atmnrs, box)
E, F = ChemGP.calculate(pot, positions)

# Use as a GP optimization oracle (gradient = -forces)
oracle = make_rpc_oracle(pot)
```

--------------------------------

### Build and Test Eon with Nix (Bash)

Source: https://github.com/theochemui/eon/blob/main/Deprecated_Docs.org

Instructions for building and installing the Eon project using Nix. It includes commands for debugging build errors and adding the built package to the Nix environment. It also shows how to enter a development shell for working on the packages.

```bash
# Debug errors
nix-build -K .
# Add to path
nix-env -if .
# With gcc
nix-shell --pure --run bash --show-trace --verbose
# With clang
nix-shell --argstr clang --pure --run bash --show-trace --verbose
```

--------------------------------

### Configure eOn Main Section Job Type (TOML)

Source: https://github.com/theochemui/eon/blob/main/docs/source/user_guide/index.md

This snippet demonstrates how to set the 'job_type' in the '[Main]' section of an eOn configuration file using TOML format. TOML is used for configuration files starting from version 3.1.

```toml
[Main]
job_type = "process_search"

```

--------------------------------

### Start EON Server

Source: https://github.com/theochemui/eon/blob/main/docs/source/tutorials/akmc.md

Initiates the EON server, which registers results from previous executions and makes new process searches. The initial run creates state directories and performs two saddle searches.

```bash
eOngit/examples/akmc-pt on main via 🅒 eongit
➜ python -m eon.server
Eon version 1d9860cf
State list path does not exist; Creating: .//states/
Registering results
Processed 0 results
Queue contains 0 searches
Making 2 process searches
Job finished: .//jobs/scratch/0_0
Job finished: .//jobs/scratch/0_1
Created 2 searches
Currently in state 0 with confidence 0.000000
```

--------------------------------

### Build LAMMPS with QUIP Support

Source: https://github.com/theochemui/eon/blob/main/docs/source/user_guide/quip.md

Clones the LAMMPS repository and builds it as a shared library, specifically linking it to the previously built QUIP library. It configures the build using CMake, disabling MPI and enabling the ML-QUIP and MANYBODY packages. The installation prefix is set to the conda environment.

```bash
git clone https://github.com/lammps/lammps
cd lammps
mkdir build; cd build
# The QUIP_LIB_DIR_BLD is special, needs to be populated from the QUIP foldercmake ../cmake -D CMAKE_INSTALL_PREFIX=$CONDA_PREFIX -D DOWNLOAD_QUIP=no -DQUIP_LIBRARY=$QUIP_LIB_DIR_BLD/libquip.a -DBUILD_SHARED_LIBS=yes -D PKG_ML-QUIP=yes -D BUILD_MPI=no -D PKG_MANYBODY=yes
make -j$(nproc)
make install
cd build
export LMP_BLD_DIR=$(pwd)
```

--------------------------------

### Iterate EON Server with Bash Loop

Source: https://github.com/theochemui/eon/blob/main/docs/source/tutorials/akmc.md

Demonstrates how to quickly iterate over states by using a bash `for` loop to execute the EON server multiple times. This is useful for exploring a larger phase space until a KMC step can be taken.

```bash
eOngit/examples/akmc-pt on main via 🅒 eongit took 7s
➜ for i in {0..60}; do python -m eon.server; done
```

--------------------------------

### Configure Cluster Communicator in TOML

Source: https://github.com/theochemui/eon/blob/main/docs/source/user_guide/communicator.md

Example TOML configuration for the cluster communicator in eOn. It defines the communicator type as 'cluster', sets a name prefix for jobs, and specifies the path to the cluster's script directory. This is used for submitting jobs to a cluster via a job queuing system like SGE.

```toml
[Communicator]
type = "cluster"
name_prefix = "al_diffusion_"
script_path = "/home/user/eon/tools/clusters/sge6.2"
```

--------------------------------

### Build Eon Client on macOS with Meson (Bash)

Source: https://github.com/theochemui/eon/blob/main/Deprecated_Docs.org

This snippet outlines the steps for building the Eon client on macOS using Meson. It covers generating a version header, setting up the build directory with specific options, and compiling the project.

```bash
cd client
./version.sh > version.h
meson setup builddir -Dwith_ams=true -Dwith_gprd=true --buildtype=release
VERBOSE=1 meson compile -C builddir
```

--------------------------------

### Eon Serve Command Reference

Source: https://github.com/theochemui/eon/blob/main/docs/source/user_guide/serve_mode.md

Lists and describes the command-line flags available for running the Eon potential in serve mode.

```APIDOC
## Command Reference

### Description
This section details the command-line flags used to configure and run the Eon potential in serve mode.

### Flags

- **`--serve <spec>`**: Specifies the potentials to serve. The format is `pot:port` or `pot:host:port`. Multiple specifications can be provided, separated by commas.
- **`--serve-host <host>`**: Sets the hostname for single-potential mode. Defaults to `localhost`.
- **`--serve-port <port>`**: Sets the port for single-potential mode when using the `-p` flag. Defaults to `12345`.
- **`--replicas <N>`**: Defines the number of server instances or the size of the gateway pool. Defaults to `1`.
- **`--gateway`**: Enables gateway mode, which uses a single port to manage a round-robin pool of server instances.
- **`--config <file>`**: Specifies an INI configuration file containing potential and serve parameters.
- **`-p <potential>`**: Indicates the potential type to be used, typically in conjunction with `--serve-port`.
```

--------------------------------

### Build and Run Tests with Meson

Source: https://github.com/theochemui/eon/blob/main/Readme.org

Sets up and runs unit tests for the client component using Meson. This process involves navigating to the client directory, configuring the build with test support enabled, and then executing the tests. It's the preferred method for testing.

```bash
cd client
# in pixi, add --prefix=$CONDA_PREFIX --libdir=lib
meson setup bbdir --buildtype=debug -Dbuild_tests=true
meson test -C bbdir
```

--------------------------------

### Install Aluminum Library

Source: https://github.com/theochemui/eon/blob/main/client/potentials/Aluminum/CMakeLists.txt

Installs the Aluminum target using CMake's install command. This makes the built library available for use by other projects or for deployment.

```cmake
install(TARGETS Aluminum)

```

--------------------------------

### Build Eon with Make (Bash)

Source: https://github.com/theochemui/eon/blob/main/Deprecated_Docs.org

This code shows the older method of building the Eon project using Make. It includes commands to compile the project and add the current directory to the PATH.

```bash
cd client
make -j$(nproc) # Will break
make # Will not break now
export PATH=$(pwd):$PATH
```

--------------------------------

### Install EMT Target

Source: https://github.com/theochemui/eon/blob/main/client/potentials/EMT/CMakeLists.txt

Installs the built EMT target. This makes the library available for use in other projects or for deployment.

```cmake
install(TARGETS EMT)
```

--------------------------------

### Install ASE_ORCA Target

Source: https://github.com/theochemui/eon/blob/main/client/potentials/ASE_ORCA/CMakeLists.txt

Installs the built ASE_ORCA target. This makes the library available for use in other projects or for deployment.

```cmake
install(TARGETS ASE_ORCA)
```

--------------------------------

### Run eonclient and Verify Energy and Forces

Source: https://github.com/theochemui/eon/blob/main/client/potentials/Metatomic/readme.org

This bash script copies a configuration file and then runs the eonclient. The output shows the calculated energy and maximum atomic force, which are used for verification against expected values.

```bash
cp docs/lj13.con pos.con
eonclient
# Energy:         98374.877530582715
# Max atom force: 109591.908376179999
```

--------------------------------

### View Simulation Dynamics Data (Bash)

Source: https://github.com/theochemui/eon/blob/main/docs/source/tutorials/parrep.md

This command displays the content of the 'dynamics.txt' file, which contains detailed information about the simulation steps, including step time, total time, barrier, rate, and energy.

```bash
cat dynamics.txt

```

--------------------------------

### Run eonclient in Gateway Mode

Source: https://context7.com/theochemui/eon/llms.txt

Starts eonclient in gateway mode, allowing a single port to serve multiple replicas. This simplifies client connections by providing a unified interface to a pool of computational resources.

```bash
eonclient -p lj --serve-port 12345 --replicas 6 --gateway
```

--------------------------------

### Install ZBL Library Target

Source: https://github.com/theochemui/eon/blob/main/client/potentials/ZBL/CMakeLists.txt

Installs the ZBL library target. This makes the compiled ZBL library available for use in other projects or for deployment.

```cmake
install(TARGETS ZBL)
```

--------------------------------

### Install Metatomic Library

Source: https://github.com/theochemui/eon/blob/main/client/potentials/Metatomic/CMakeLists.txt

Installs the Metatomic target. This CMake command makes the built Metatomic library available for use in other projects or for deployment.

```cmake
install(TARGETS Metatomic)
```

--------------------------------

### Install EAM Target

Source: https://github.com/theochemui/eon/blob/main/client/potentials/EAM/CMakeLists.txt

Installs the EAM target as part of the build process. This makes the EAM library available for use in other projects or for deployment.

```cmake
install(TARGETS EAM)
```

--------------------------------

### Install NewPot Library (CMake)

Source: https://github.com/theochemui/eon/blob/main/client/potentials/NewPot/CMakeLists.txt

This CMake command specifies that the NewPot target should be installed. This makes the library available for use in other projects or for deployment.

```cmake
install(TARGETS NewPot)
```

--------------------------------

### Run Manual Eon Client Tests (Bash)

Source: https://github.com/theochemui/eon/blob/main/Deprecated_Docs.org

This snippet demonstrates how to manually run the Eon client executable for testing purposes. It involves navigating to a specific test data directory and executing the client.

```bash
# From root repo directory
cd client/gtests/data/saddle_search/
eonclient
```

--------------------------------

### Install rgpycrumbs Package

Source: https://github.com/theochemui/eon/blob/main/docs/source/tutorials/dict_config.md

Installs the rgpycrumbs package, which provides the write_eon_config function for generating eOn configuration files from Python dictionaries. This can be done using pip or uv.

```bash
pip install rgpycrumbs
# or
uv add rgpycrumbs
```

--------------------------------

### Install eOn using micromamba

Source: https://github.com/theochemui/eon/blob/main/docs/source/index.md

Installs the eOn package and its dependencies using the micromamba package manager from the conda-forge channel. This is the primary method for setting up eOn.

```bash
micromamba install -c conda-forge eon
```

--------------------------------

### Run eonclient with config.ini and pos.con

Source: https://github.com/theochemui/eon/blob/main/docs/source/index.md

Initiates an eonclient simulation using a configuration file ('config.ini') and a position file ('pos.con'). The client automatically reads these files to set up and run the simulation.

```bash
eonclient # reads config.ini and runs
```

--------------------------------

### Install Git Hook for Pre-commit

Source: https://github.com/theochemui/eon/blob/main/Readme.org

Installs the git hook for pre-commit, automating the execution of checks on every commit. This helps maintain code standards throughout the development process.

```bash
uvx prek install
```

--------------------------------

### Configure QuickMin Optimizer

Source: https://context7.com/theochemui/eon/llms.txt

INI configuration for the QuickMin optimizer. This method is useful for rapid initial geometry relaxation, particularly in the early stages of NEB calculations.

```ini
# QuickMin (good for early NEB stages)
[Optimizer]
opt_method = quickmin
converged_force = 0.01
```

--------------------------------

### Running Minimization with eonclient (Bash)

Source: https://context7.com/theochemui/eon/llms.txt

Command-line instruction to perform local energy minimization using the `eonclient`. This requires specifying the input structure, potential, and the minimization flag.

```bash
# Run minimization with eonclient directly
eonclient -s structure.con -p eam_al --minimize

```

--------------------------------

### Uninstall Old eOn Version (Bash)

Source: https://github.com/theochemui/eon/blob/main/docs/source/tutorials/CECAM_LTS_MAP_2024/troubleshooting.md

Removes the existing eOn installation directory and its associated environment variables from the .bashrc file. This ensures a clean slate for a new installation. It requires bash shell access.

```bash
# Remove the directory
rm -rf "$HOME/software/eon"
# Remove the paths
sed -i.bak '/export PYTHONPATH=$HOME/software/eon:$PYTHONPATH/d; /export PATH=$HOME/software/eon/bin:$HOME/bin:/opt/bin:$PATH/d' "$HOME/.bashrc"
# Refresh the shell
source "$HOME/.bashrc"
```

--------------------------------

### Build Eon Client on Linux with CMake and Ninja (Bash)

Source: https://github.com/theochemui/eon/blob/main/Deprecated_Docs.org

This code block details the process of building the Eon client on Linux using CMake and Ninja. It includes steps for configuring the build with specific options, compiling the project, and running tests.

```bash
cd client
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Debug -DUNIX=TRUE -DPACKAGE_TESTS=ON -DNO_WARN=TRUE -DFIND_EIGEN=TRUE -DCMAKE_EXPORT_COMPILE_COMMANDS=1 -DWITH_GPRD=TRUE -DWITH_FORTRAN=FALSE -G "Ninja"
VERBOSE=1 ninja
ctest
```