Neural density functional theory of liquid-liquid phase coexistence

This repository contains the code, datasets, and models accompanying the publication:

Learning the bulk and interfacial physics of liquid-liquid phase separation

To be published

arXiv

Abstract

We use simulation-based supervised machine learning and classical density functional theory to investigate bulk and interfacial phenomena associated with phase coexistence in binary mixtures. For a prototypical symmetrical Lennard-Jones mixture our trained neural density functional yields accurate liquid-liquid and liquid-vapour binodals together with predictions for the variation of the associated interfacial tensions across the entire fluid phase diagram. From the latter we determine the contact angles at fluid-fluid interfaces along the line of triple-phase coexistence and confirm there can be no wetting transition in this symmetrical mixture.

Introduction

This codebase serves to demonstrate how a trained c1-Functional, within the framework of classical Density Functional Theory (cDFT), can be used to generate accurate density profiles for liquid-liquid and liquid-vapor transitions.
Methods beyond profile generation, such as functional integration to calculate the free energy and surface tension, are outside the scope of this repository.

Note: You are currently viewing the main branch.
This branch implements the binary mixture version of the neural DFT framework.
The single-species version can be found in the onespecies branch

Setup

The Python version used during development was Python 3.12.5. For other Python versions, please refer to documentation.

Working in a virtual environment is highly recommended and make sure to have all the dependencies installed:

# Set up environment
python3 -m venv .venv
source .venv/bin/activate

# Install Pytorch with Cudasupport ((use --index-url to control the version))
pip install torch torchvision torchaudio

# Install other dependencies
pip install -r requirements.txt

If problems arise with using a GPU for Pytorch, refer to the official installation guide at https://pytorch.org/get-started/locally/. Make sure that the CUDA drivers, Python version and Pytorch version are compatible with each other.

Instructions

Key directories:

• scripts/: Contains the scripts on how to use the trained Functionals to create interfacial profiles
• results/: The default output directory for generated profiles.
• train/: Contains the scripts for training a neural network
• models/: Contains pre-trained neural functional models.
• simdata/: Contains the reference Grand Canonical Monte Carlo simulation data used for training.

Generating Density Profiles

The script scripts/generate_profiles.py demonstrates how to use a trained neural network to create self-consistent density profiles for various interfaces (liquid-liquid, vapor-demixed liquid, etc.).

To run with the pre-trained model, simply execute the script:

python3 scripts/generate_profiles.py

The resulting profiles will be saved in the results/ directory.

Training a New Model

For users interested in training a new model from scratch, a sample script is provided in train/learn.py.

Before execution, it is advisable to configure training parameters (e.g., epochs, number of workers) by editing the train/learn.py script directly.

To start the training process, run:

python3 train/learn.py

Note: The data included in this repository is a small subset (200 of 2200 runs) for quick testing. The complete training dataset is available on Zenodo. To use the full dataset, download it and update the run_dir variable in learn.py to point to the new data directory.

Training can be resource-intensive, especially when using the complete dataset. For multi-process data loading, it may be necessary to increase the system's limit for open file descriptors (e.g., ulimit -n 4096 on Linux/macOS).

The network architecture can be found in train/model.py whereas the logic to generate the training dataset is located in train/dataset.py.

Further Information

NEW: Added a new refined model refined_model_with_L2.pth. Additional Info can be found on the Zenodo. To use the Net, change in scripts/generate_profiles.py the following line:

from model import NetC1

to

from model_refined import NetC1

NEW: Additional onespecies branch for single-species Neural DFT

The reference data in simdata/selected_runs was generated with Grand Canonical Monte Carlo simulations using the MBD software package.

The folder train/mbd and the script train/runanalyzer.py are used to process the reference data.

The corresponding utility functions are available in train/utils.py and scripts/utils.py.