ase-uhal 0.1.0__tar.gz

ase_uhal-0.1.0/CODE_OF_CONDUCT.md

@@ -0,0 +1,77 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age,
+body size, disability, ethnicity, gender identity and expression, level of
+experience, nationality, personal appearance, race, religion, or sexual
+identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+Moreover, project maintainers will strive to offer feedback and advice to
+ensure quality and consistency of contributions to the code.  Contributions
+from outside the group of project maintainers are strongly welcomed but the
+final decision as to whether commits are merged into the codebase rests with
+the team of project maintainers.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an
+appointed representative at an online or offline event. Representation of a
+project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at 'Thomas.Rocke@warwick.ac.uk'. The project team will
+review and investigate all complaints, and will respond in a way that it deems
+appropriate to the circumstances. The project team is obligated to maintain
+confidentiality with regard to the reporter of an incident. Further details of
+specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.4, available at
+[http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

ase_uhal-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+
+MIT License
+
+Copyright (c) 2025 Thomas Rocke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ase_uhal-0.1.0/MANIFEST.in

@@ -0,0 +1,6 @@
+include LICENSE
+include README.md
+include CODE_OF_CONDUCT.md
+
+global-exclude *.py[cod] __pycache__ *.so
+prune ase_uhal/tests

ase_uhal-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: ase-uhal
+Version: 0.1.0
+Summary: Implementation of 'Universal HyperActive Learning' compatible with the Atomic Simulation Environment (ASE)
+Author-email: Thomas Rocke <Thomas.Rocke@warwick.ac.uk>, James Kermode <J.R.Kermode@warwick.ac.uk>
+License-Expression: MIT
+Project-URL: Source, https://github.com/kermodegroup/ase_uhal
+Project-URL: Documentation, https://kermodegroup.github.io/ase_uhal/
+Project-URL: Bug Tracker, https://github.com/kermodegroup/ase_uhal/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Development Status :: 3 - Alpha
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ase
+Requires-Dist: numpy
+Requires-Dist: scipy
+Provides-Extra: mace
+Requires-Dist: mace-torch; extra == "mace"
+Requires-Dist: torch; extra == "mace"
+Requires-Dist: e3nn; extra == "mace"
+Provides-Extra: ace
+Requires-Dist: juliacall; extra == "ace"
+Requires-Dist: juliapkg; extra == "ace"
+Provides-Extra: docs
+Requires-Dist: Sphinx; extra == "docs"
+Requires-Dist: pydata-sphinx-theme; extra == "docs"
+Requires-Dist: sphinxcontrib-bibtex>2.6; extra == "docs"
+Requires-Dist: nbsphinx; extra == "docs"
+Requires-Dist: ipython; extra == "docs"
+Requires-Dist: ipykernel; extra == "docs"
+Requires-Dist: pypandoc; extra == "docs"
+Requires-Dist: sphinx_design; extra == "docs"
+Requires-Dist: sphinx-copybutton; extra == "docs"
+Requires-Dist: nglview; extra == "docs"
+Requires-Dist: ase_uhal[ace,mace]; extra == "docs"
+Provides-Extra: test
+Requires-Dist: pytest>=6.1.2; extra == "test"
+Requires-Dist: pytest_allclose; extra == "test"
+Requires-Dist: ase_uhal[ace,mace]; extra == "test"
+Dynamic: license-file
+
+ase_uhal
+==============================
+[//]: # (Badges)
+[![GitHub Actions Build Status](https://github.com/kermodegroup/ase_uhal/workflows/CI/badge.svg)](https://github.com/kermodegroup/ase_uhal/actions?query=workflow%3ACI)
+[![codecov](https://codecov.io/gh/kermodegroup/ase_uhal/branch/main/graph/badge.svg)](https://codecov.io/gh/kermodegroup/ase_uhal/branch/main)
+
+
+Implementation of "Universal HyperActive Learning" compatible with the Atomic Simulation Environment (ASE)
+
+### Documentation
+Documentation is available at https://kermodegroup.github.io/ase_uhal/
+
+
+### Base Installation
+Requires:
+- Python >= 3.10
+- Julia >= 1.11 (for ACE descriptor features)
+
+**_NOTE:_**  This package is intended to always be used in conjunction with additional dependencies, see the next section for more information.
+
+Basic installation can be achieved via pip
+```bash
+pip install ase-uhal
+
+```
+
+You can also clone the Git repository:
+```bash
+git clone https://github.com/kermodegroup/ase_uhal.git
+cd ase_uhal
+pip install .
+```
+
+### Extra Dependencies
+`ase_uhal` supports interfaces to multiple MLIP architectures. To avoid a very large number of mandatory dependencies, specific requirements for each MLIP model are implemented as optional dependencies to this package. For example, to install the MACE compatibility,
+```bash
+pip install ase-uhal[mace]
+```
+
+#### ACE Installation
+ACE installation is more complex, as it requires a connection between Python and Julia, both with the correct modules installed. This is handled by `pyjuliapkg`, and can be achieved via:
+```bash
+pip install .[ace]
+python -c "import ase_uhal; ase_uhal.install_ace_deps()"
+```
+For more details on this, including customising the Julia installation, see the documentation.
+
+### Copyright
+
+Copyright (c) 2025, Thomas Rocke
+
+
+#### Acknowledgements
+ 
+Project based on the 
+[Computational Molecular Science Python Cookiecutter](https://github.com/molssi/cookiecutter-cms) version 1.11.

ase_uhal-0.1.0/README.md

@@ -0,0 +1,56 @@
+ase_uhal
+==============================
+[//]: # (Badges)
+[![GitHub Actions Build Status](https://github.com/kermodegroup/ase_uhal/workflows/CI/badge.svg)](https://github.com/kermodegroup/ase_uhal/actions?query=workflow%3ACI)
+[![codecov](https://codecov.io/gh/kermodegroup/ase_uhal/branch/main/graph/badge.svg)](https://codecov.io/gh/kermodegroup/ase_uhal/branch/main)
+
+
+Implementation of "Universal HyperActive Learning" compatible with the Atomic Simulation Environment (ASE)
+
+### Documentation
+Documentation is available at https://kermodegroup.github.io/ase_uhal/
+
+
+### Base Installation
+Requires:
+- Python >= 3.10
+- Julia >= 1.11 (for ACE descriptor features)
+
+**_NOTE:_**  This package is intended to always be used in conjunction with additional dependencies, see the next section for more information.
+
+Basic installation can be achieved via pip
+```bash
+pip install ase-uhal
+
+```
+
+You can also clone the Git repository:
+```bash
+git clone https://github.com/kermodegroup/ase_uhal.git
+cd ase_uhal
+pip install .
+```
+
+### Extra Dependencies
+`ase_uhal` supports interfaces to multiple MLIP architectures. To avoid a very large number of mandatory dependencies, specific requirements for each MLIP model are implemented as optional dependencies to this package. For example, to install the MACE compatibility,
+```bash
+pip install ase-uhal[mace]
+```
+
+#### ACE Installation
+ACE installation is more complex, as it requires a connection between Python and Julia, both with the correct modules installed. This is handled by `pyjuliapkg`, and can be achieved via:
+```bash
+pip install .[ace]
+python -c "import ase_uhal; ase_uhal.install_ace_deps()"
+```
+For more details on this, including customising the Julia installation, see the documentation.
+
+### Copyright
+
+Copyright (c) 2025, Thomas Rocke
+
+
+#### Acknowledgements
+ 
+Project based on the 
+[Computational Molecular Science Python Cookiecutter](https://github.com/molssi/cookiecutter-cms) version 1.11.

ase_uhal-0.1.0/ase_uhal/__init__.py

@@ -0,0 +1,6 @@
+"""Implementation of "Universal HyperActive Learning" compatible with the Atomic Simulation Environment (ASE)"""
+
+# Add imports here
+from .structure_selector import StructureSelector
+from .ace_installer import install_ace_deps
+from ._version import __version__

ase_uhal-0.1.0/ase_uhal/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

ase_uhal-0.1.0/ase_uhal/ace_installer.py

@@ -0,0 +1,22 @@
+
+def install_ace_deps():
+    try:
+        import juliapkg
+    except ImportError as e:
+        err_text = ("ase_uhal is not installed with ACE compatibility.\n"
+                  + " "*13 # Indentation
+                  + "Run `pip install ase_uhal[ace]` to resolve"
+        )
+        raise ImportError(err_text) from e
+    
+    juliapkg.resolve() # Initial resolve to make sure general registry exists
+    juliapkg.add("JSON")
+    juliapkg.add("Unitful")
+    juliapkg.add("AtomsBase")
+    juliapkg.add("AtomsCalculators")
+    # juliapkg does not yet seem to support >= specifiers
+    # Hack a >= using wildcard version bounds 0.10 - 0.* === [0.10.0, 1.0.0)
+    juliapkg.add("ACEpotentials", version="0.10 - 0")
+
+    # resolve() tries to download and install packages which were missing or at incorrect versions
+    juliapkg.resolve()

ase_uhal-0.1.0/ase_uhal/bias_calculators.py

@@ -0,0 +1,153 @@
+'''
+ase-compatible HAL-style bias calculator, using the committee error as an energy bias.
+
+'''
+from ase.calculators.calculator import Calculator
+import numpy as np
+from .committee_calculators.base_committee_calculator import BaseCommitteeCalculator
+from abc import ABCMeta, abstractmethod
+from ase.stress import voigt_6_to_full_3x3_stress
+
+class BaseBiasCalculator(Calculator, metaclass=ABCMeta):
+    '''
+    ASE-compatible Bias calculator with adaptive biasing
+
+    Derived from a combination of ACEHAL.bias_calc.BiasCalculator and ACEHAL.bias_calc.TauRelController from ACEHAL
+    https://github.com/ACEsuit/ACEHAL/blob/main/ACEHAL/bias_calc.py
+    
+    '''
+    implemented_properties = ['energy', 'forces', 'stress']
+    default_parameters = {}
+    name = 'HALCalculator'
+
+    def __init__(self, mean_calc, committee_calc:BaseCommitteeCalculator, adaptive_tau=False, tau_rel=0.1, tau_hist=10, tau_delay=None, eps=0.2):
+        '''
+        '''
+
+        super().__init__()
+        self.mean_calc = mean_calc
+        self.committee_calc = committee_calc
+        self.adapt_tau = adaptive_tau
+        self.tau_rel = tau_rel
+        self.tau_hist = tau_hist
+        if tau_delay is not None:
+            self.tau_delay = tau_delay
+        else:
+            self.tau_delay = tau_hist
+        
+        self._tau_delay = self.tau_delay
+
+        self.tau = 0 # Default to no mixing, until specified by user, or changed by adaptive mode
+        self.Fmean = None
+        self.Fbias = None
+        self.eps = eps
+
+        # Validation
+        assert self.tau_rel > 0
+        assert self.mixing > 0
+        assert self.tau_delay > 0
+
+    @property
+    def mixing(self):
+        return 1/self.tau_hist
+    
+    @mixing.setter
+    def mixing(self, mixing):
+        self.tau_hist = 1/mixing
+            
+    def calculate(self, atoms, properties, system_changes):
+        '''
+        Overload of the BaseCalculator.calculate() abstract method
+        Calculate props combining the results from the mean_calc with the results from the committee
+        '''
+        super().calculate(atoms, properties, system_changes)
+
+        if len(system_changes):
+            self.results = {}
+
+        assert self.tau is not None
+
+        self.committee_calc.calculate(atoms, ["bias_" + prop for prop in properties], system_changes)
+
+        self.mean_calc.calculate(atoms, properties, system_changes)
+
+        for prop in self.implemented_properties:
+            if prop in properties:
+                mean_prop = self.mean_calc.results[prop]
+                if prop == "stress" and mean_prop.shape != (3, 3):
+                    mean_prop = voigt_6_to_full_3x3_stress(mean_prop)
+                # Use get_property as an interface to committee_calc, as torch-based comm calcs will use torch.Tensor in self.results 
+                self.results[prop] = mean_prop - self.tau * self.committee_calc.get_property("bias_" + prop, atoms)
+
+    def update_tau(self, atoms=None):
+        '''
+        Exponential mixing of mean force magnitude and mean biasing force magnitude 
+        (without the tau biasing constant)
+
+        Updates self.Fmean and self.Fbias based on self.mixing to mix between old values 
+        and the new values provided as arguments 
+        Modifies self.tau if self.tau_delay < 0, otherwise decreases self.tau_delay by 1
+        '''
+        Fmean = np.mean(np.linalg.norm(self.get_property("forces", atoms), axis=-1))
+        Fbias = np.mean(np.linalg.norm(self.committee_calc.get_property("bias_forces", atoms), axis=-1))
+
+        if self.Fmean is None or self.Fbias is None:
+            self.Fmean = Fmean
+            self.Fbias = Fbias
+        else:
+            self.Fmean = (1-self.mixing) * self.Fmean + self.mixing * Fmean
+            self.Fbias = (1-self.mixing) * self.Fbias + self.mixing * Fbias
+        
+        if self._tau_delay > 0:
+            # Positive delay means tau should not yet be updated
+            # Updates to self.Fmean and self.Fbias needed to ensure 
+            # smooth averaging when tau can be changed
+            self._tau_delay -= 1
+        else:
+            self.tau = self.tau_rel * (self.Fmean / self.Fbias)
+
+    def reset_tau(self):
+        '''
+        Sets the biasing strength to zero, and resets the internal tau mixing state
+        '''
+
+        self.tau = 0
+        self.Fmean = None
+        self.Fbias = None
+        self._tau_delay = self.tau_delay
+
+    @abstractmethod
+    def get_score(self, atoms=None):
+        pass
+
+    def select_structure(self, ats):
+        '''
+        Alias for self.committee_calc.select_structure
+        '''
+        self.committee_calc.select_structure(ats)
+
+    def resample_committee(self, committee_size=None):
+        '''
+        Alias for self.committee_calc.resample_committee
+        '''
+        self.committee_calc.resample_committee(committee_size)
+
+    def sync(self):
+        '''
+        Alias of self.committee_calc.sync()
+        '''
+        self.committee_calc.sync()
+    
+class HALBiasCalculator(BaseBiasCalculator):
+    '''
+    Bias calculator with HAL scoring metric    
+    '''
+    def get_score(self, atoms=None):
+        Fmean = np.linalg.norm(self.get_property("forces", atoms), axis=-1)
+        Fbias = np.linalg.norm(self.committee_calc.get_property("bias_forces", atoms), axis=-1)
+        
+        F = Fbias / (Fmean + self.eps)
+
+        s = np.exp(F) / (np.sum(np.exp(F)) + self.eps) # Apply softmax
+
+        return np.max(s)

ase_uhal-0.1.0/ase_uhal/committee_calculators/__init__.py

@@ -0,0 +1,4 @@
+from .ace_committee_calculator import ACE1Calculator, ACEHALCalculator
+from .mace_committee_calculator import MACEHALCalculator
+from .base_committee_calculator import BaseCommitteeCalculator
+from .torch_committee_calculator import TorchCommitteeCalculator

ase_uhal-0.1.0/ase_uhal/committee_calculators/ace_committee_calculator.py

@@ -0,0 +1,172 @@
+from .base_committee_calculator import BaseCommitteeCalculator, HALBiasPotential, Calculator
+import os
+import numpy as np
+from abc import ABCMeta, abstractmethod
+
+file_root = os.path.dirname(os.path.abspath(__file__))
+
+class BaseACECalculator(BaseCommitteeCalculator, metaclass=ABCMeta):
+    implemented_properties = ['energy', 'forces', 'stress', 'desc_energy', 'desc_forces', 'desc_stress', 
+                              'comm_energy', 'comm_forces', 'comm_stress', 'bias_energy', 'bias_forces', 'bias_stress']
+    def __init__(self, ace_params, committee_size, prior_weight, **kwargs):
+        '''
+        Parameters
+        ----------
+        ace_params: string or dict
+            If ace_params is a string: Use ACEpotentials.load_model to load the model json file given by ace_params
+            If ace_params is a dict: interpret ace_params as the hyperparameters dict for ACEpotentials.ace1_model e.g.
+
+            .. code-block:: python
+            
+                ace_params = {"elements" : ["Si"], # Expects list of str 
+                              "order" : 3, # Expects an int
+                              "totaldegree" : 10, # Expects an int
+                              "rcut" : 5.0 # Expects a float
+                             }
+
+
+        committee_size: int
+            Number of members in the linear committee
+        prior_weight: float
+            Weight corresponding to the prior matrix in the linear system
+        **kwargs: Keyword Args
+            Extra keywork arguments fed to :class:`~ase_uhal.committee_calculators.BaseCommitteeCalculator`
+        
+        '''
+            
+        from juliacall import Main as jl
+
+
+        self.jl = jl
+        # ACEpotentials, plus some utilities
+        self.jl.seval('include("' + os.path.normpath(file_root + "/../data/_ace_utils.jl") + '")')
+
+        if type(ace_params) == str:
+            # assume filename
+            self.model = self.jl.load_ace(ace_params)
+        else:
+            # assume set of ace hyperparameters
+            if type(ace_params) == list:
+                elements, order, totaldegree, rcut = ace_params
+            else: # Dict
+                elements = ace_params["elements"]
+                order = ace_params["order"]
+                totaldegree = ace_params["totaldegree"]
+                rcut = ace_params["rcut"]
+            self.model = self.jl.model_from_params(elements, order, totaldegree, rcut)
+
+        descriptor_size = self.jl.length_basis(self.model)
+
+        super().__init__(committee_size, descriptor_size, prior_weight, **kwargs)
+        
+    def _prep_atoms(self, atoms):
+        '''
+        Convert from ase atoms into the AtomsBase AbstractSystem, using ASEconvert
+        '''
+        numbers = atoms.get_atomic_numbers()
+        positions = atoms.positions
+        cell = atoms.cell[:, :]
+        pbc = atoms.pbc
+
+        return self.jl.convert_ats(numbers, positions, cell, pbc)
+    
+    @abstractmethod
+    def _bias_energy(self, comm_energy):
+        pass
+
+    @abstractmethod
+    def _bias_forces(self, comm_forces, comm_energy):
+        pass
+
+    @abstractmethod
+    def _bias_stress(self, comm_stress, comm_energy):
+        pass
+    
+    def calculate(self, atoms, properties, system_changes):
+        '''
+        Calculation for descriptor properties, committee properties, normal properties, and HAL properties
+
+        Descriptor properties use a "desc_" prefix, committee properties use "comm_", HAL properties use "hal_".
+        
+        '''
+        super().calculate(atoms, properties, system_changes)
+
+        if "desc_energy" not in self.results.keys():
+            # System has changed, need to recalculate base descriptors
+            E, F, V = self.jl.eval_basis(self._prep_atoms(atoms), self.model)
+
+            self.results["desc_energy"] = np.array(E)
+            self.results["desc_forces"] = np.array(F)
+            self.results["desc_stress"] = -np.array(V) / atoms.get_volume()
+
+        for key in ["energy", "forces", "stress"]:
+            if "comm_" + key in properties or key in properties or "bias_" + key in properties or key == "energy": 
+                # Always calculate energy properties, as committee energies 
+                # needed for force and stress bias calc
+                comm_prop = np.tensordot(self.committee_weights, self.results["desc_" + key], axes=1)
+                self.results["comm_" + key] = comm_prop
+
+                self.results[key] = np.mean(comm_prop, axis=0)
+
+        if "bias_energy" in properties:
+            self.results["bias_energy"] = self._bias_energy(self.results["comm_energy"])
+
+        if "bias_forces" in properties:
+            self.results["bias_forces"] = self._bias_forces(self.results["comm_forces"], self.results["comm_energy"])
+
+        if "bias_stress" in properties:
+            self.results["bias_stress"] = self._bias_stress(self.results["comm_stress"], self.results["comm_energy"])
+
+
+class ACE1Calculator(Calculator):
+    '''
+    Basic ACE1 ASE calculator interface, assumes json structure similar to the ACEpotentials tutorial example
+
+    NOTE: model_name = "ACE1" added to the hyperparameters dict
+
+    hyperparams = (elements = [:Ti, :Al],
+					order = 3,
+					totaldegree = 6,
+					rcut = 5.5,
+					Eref = [:Ti => -1586.0195, :Al => -105.5954],
+                    model_name = "ACE1"
+                    )
+
+    using JSON
+    open("TiAl_model.json", "w") do f
+        JSON.print(f, Dict("hyperparams" => hyperparams, "params" => model.ps))
+    end
+    
+    '''
+    implemented_properties = ["energy", "forces", "stress"]
+    def __init__(self, pot_json):
+        super().__init__()
+
+        from juliacall import Main as jl
+        self.jl = jl
+        self.jl.seval('include("' + os.path.normpath(file_root + "/../data/_ace_utils.jl") + '")')
+        
+        self.pot_json = pot_json
+
+
+        self.acemodel = jl.load_ace(pot_json, True)
+
+    def calculate(self, atoms, properties, system_changes):
+        super().calculate(atoms, properties, system_changes)
+        self.results = {}
+
+        jl_ats = self.jl.convert_ats(atoms.numbers, atoms.positions, atoms.cell[:, :], atoms.pbc)
+
+        E, F, V = self.jl.eval_observables(jl_ats, self.acemodel)
+
+        F = np.array(F).T; V = np.array(V)
+
+        S = -V/atoms.get_volume()
+
+        self.results["energy"] = E
+        self.results["forces"] = F
+        self.results["stress"] = S
+
+
+class ACEHALCalculator(HALBiasPotential, BaseACECalculator):
+    name = "ACEHALCalculator"