Author: admin

How close can we get to the lowest energy molecular structures just by maximizing packing density? Let’s compare the structures Andy obtained from Materials Studio by minimising some force-field potential

with the structures I got from maximizing packing density: https://milotorda.net/getting-loads-of-sufficiently-dense-structures/ .

To get a clearer view, we took Andy’s set, created a neighborhood around the packing coefficient, divided the interval into bins, and in each bin, selected the lowest energy structure. Then, we calculated the energies of these structures using VASP’s DFT (PBE) and computed the packing density via https://milotorda.net/exercise-in-monte-carlo-density-computation/

Next, we selected around structures generated here https://milotorda.net/getting-loads-of-sufficiently-dense-structures/ and computed their energies using VASP’s DFT, just like we did for Andy’s set.

The energy difference between the lowest energy structure in Andy’s set and mine is . However, in Andy’s structures, the van der Waals spheres of different anthracene molecules overlap. If we filter out the structures with overlaps,

then the energy difference between the lowest energy structures in both sets is .

We then continued to further optimise the energy of all structures using VASP’s implementation of the conjugate gradient method. Here, the molecules are no longer rigid, meaning the bond lengths of the molecules in each structure change.

To be honest, I didn’t mention that we performed DFT calculations for a broader density spectrum from Andy’s CSP set. At the time of the DFT calculations, I didn’t have density estimates for all configurations, so I used the packing coefficient given by Materials Studio to guide the selection of structures. The density estimates I used are slightly different. Here is the full picture,

which brings up the question of how far from the highest density structure (in the density spectrum) do we have to look for the lowest energy structure.

I needed a way to calculate the packing densities of structures modeled using the van der Waals sphere model, generated through CSP and DFT computations. Specifically, for periodic configurations, this comes down to computing:: . Here, represents the volume of the unit cell , and is the volume of the subset of occupied by the van der Waals spheres denoted as .

Calculating the volume of is is straightforward; it’s simply the determinant of the unit cell’s generators: . However, analytically computing the volume of involves solving numerous intricate integrals of intersections of spheres with various radii, making it cumbersome.

Let’s try to do this the Monte-Carlo way, instead. The volume of can be expressed as an integral over the unit cell , i.e.

   

Here, is the natural volume form on . Since this integral is zero everywhere except in the unit cell, it can be redefined as an integral of the indicator function over the unit cell:

   

By changing coordinates to an integral over the unit cube , we get:

   

Plugging this into the density equation yields:

   

Considering as a uniform random vector on the unit cube, this integral represents the expected value of the indicator function with respect to the -variate uniform distribution. This, in turn, equals the probability of lying in the collection of the van der Waals spheres , scaled by the inverse of the unit cell:

   

This means that the crystal’s density can be estimated by sampling , counting how many fall inside , and dividing by :

   

Now, say I want to determine the density of this anthracene structure

Equivalently, I can sample uniformly from the parallelepiped defined by the unit cell, e.g. realisations,

which is . Therefore, the density estimate is .

But how accurate is this estimate? Or even better is to ask, how large does need to be so that , where is some constant?

To answer this, consider each as a Bernoulli trial. Then is binomially distributed random variable with the expected value and variance . According to the central limit theorem, the random variable converges in distribution to a normally distributed random variable with mean of and a variance of . Therefore, I can request being in the interval , and I want the size of this interval to be less then some constant with probability :

   

where is the quantile of the standard normal distribution.

For the anthracene structure mentioned earlier, to achieve with probability , I need . The density estimate in this case is then:

   

As a point of comparison, CCDC’s Mercury reports the packing coefficient of this structure as .

After running the packing algorithm, the next question is how to generate an arbitrary number of sufficiently dense structures.

One way to do this is to keep all the feasible and repaired configurations sampled at each iteration of the optimization process. For instance, after using the method described here https://milotorda.net/etrpa-repairing-unfeasible-solutions/ , I obtained packings

Still quite a lot. Lets reduce it even further by clustering. Most likely many of the structures are quite similar to each other and my goal is to identify the most dissimilar ones.

To do this, I did a single-linkage hierarchical clustering on the configurations using the standard Euclidean distance. Given that the underlying configuration space is a -dimensional unit flat torus, the metric coincides with the metric of that of , thus making sure that the single-linkage hierarchical clustering respects the geometry of my configuration space.

Suppose I want to have a selection of most distinct structures. To do this, I cut the dendrogram tree at a level where it has leaves (in terms of Topological Data Analysis I create a Čech complex with connected components)

Let’s have a look at the packing configurations of the two most distinct clusters:

These structures seem quite similar, possibly due to the limited variability allowed within the space group.

A possible problem with these configuration might be, that in most of them, are actually in contact with each other because of the repairing map, and when any two van der Waals spheres of two molecules touch, the energy should go to infinity. So, let’s try another approach.

Since the algorithm performs a Riemannian gradient ascent on a manifold of parametric probability measures, the time evolution of the distribution parameters can be thought of as a trajectory of an autonomous dynamical system. After each iteration, I save the system’s state, and when the algorithm finishes, I can return to that state and generate as many samples as necessary.

For example, after completing the run described in this post ETRPA – repairing unfeasible solutions , I take the state where the maximum packing was sampled

and generate packings with density higher than from this distribution. However, this time, I skip the repairing step and only check for overlaps. It takes a bit longer to get packings with density above without the repairing process, but the molecules do not come into contact with each other in the resulting configurations.

Let’s take a look at the distribution of these 100 configurations in my configuration space

and the two most distinct structures in this set

Again, it seems they don’t look that much different. Perhaps the best would be to merge the structures selected from the entire optimisation run with the structures generated without repair from the distribution where the maximum packing was sampled

and then use the single-linkage hierarchical clustering to create clusters

In this set of packings, are from the set of selected structures in the optimisation run, and the ramaining are from the structures sampled without repair.

Here are examples from the two most distinct clusters, one obtained from the set without repair and one from the optimisation run set:

They still look like the same configuration, just realised with alternative unit cell parameters. I’m going to blame the lack of variability in the plane group for this.

The ETRPA is designed to optimize a multi-objective function by:

1. Maximizing packing density.
2. Minimizing overlap between shapes in a configuration.

This is achieved through the use of a penalty function, which generally works quite effectively. However, there are some downsides to this approach. Many generated samples are flagged as unfeasible, leading to inefficiency. Additionally, some potentially good configurations with minimal overlaps are discarded. A more effective approach would involve mapping unfeasible solutions to feasible ones, essentially repairing the overlaps.

I’ve designed a relatively straightforward method to accomplish this almost analytically. It boils down to finding roots of a second-order polynomial, which is essentially a high school algebra problem. Admittedly, you’ll need to solve quite a few of these second-order polynomials, but they are relatively easy to handle.

So, with this approach, you can now map a configuration with overlap/s

Now, a couple of new issues have cropped up. First, there are some seriously bad solutions that are being sampled. For example, consider this one:

This is not helpful at all. Second, the parameters of this configuration are way above the optimisation boundaries that were used to create all configurations. As a result, it falls outside the configuration space where my search is taking place.

To address this issue, after repairing the configuration, I conduct a check to determine if the repaired configuration falls within my optimization boundaries. Any configurations that fall outside of these bounds are labeled as unfeasible solutions.

It might seems this puts me back in the same situation of multi-objective optimization, but that’s not the case. In my scenario, the Euclidean gradient at time takes this form:

.

Here, represents the mean of all samples in the current batch, and I only consider the configurations without overlap or the repaired ones that lie within the optimization boundaries for . This effectively means I’ve eliminated the need for the penalty function and am optimizing only based on the objective function given by the packing density.

This is a promising, but it does introduce another problem. When I repair some of the unfeasible configurations, I end up making slight alterations to the underlying probability distribution, shifting it slightly from

The issue here is that if I were to compute the Natural gradient as I used to, I’d obtain in the tangent space of the statistical manifold, where everything is unfolding, but what I actually need is in the tangent space at the point .

Fortunately, the statistical manifold of the exponential family is a flat Riemannian manifold. So, first, I move from to using this vector (where corresponds to the dual Legendre parametrization of , and to ), and then I compute the natural gradient at the point .

In addition, to increase the competition within my packing population, I introduce a sort of tournament by retaining the N-best configurations I’ve found so far and incorporating them with the repaired configurations from the current generation. This leads to yet another slightly modified distribution,

and I have to perform the same Riemannian gymnastics once more. In the end, the approximation to the natural gradient at the point is as follows

So far, experiments show that these modifications to the ETRPA are far more effective than the original ETRPA. Here’s a visualization from one of the test optimization runs:

In this particular run, the best packing I achieved attains the density of . Previously, reaching such a level of density required multiple rounds of the refinement process, each consisting of iterations. Now, a single run with just iterations is sufficient. It’s worth noting that even after only iterations, the algorithm already reaches areas with densities exceeding .

It’s important to mention that currently, I’ve only implemented the repair process for unfeasible configurations for the space group. However, similar repairs can be done for configurations in any space group. Furthermore, the algorithm’s convergence speed can be further enhanced by fine-tuning its hyperparameters. Perhaps it’s time to make use of the BARKLA cluster for the hyperparameter tuning.

Left: Anthracene, modeled as a collection of spheres, with each sphere’s radius given by the respective van der Waals radius of each atom in the molecule. Right: P1 packing of this model, with density of approximately 0.730855.

Here is a visualization showing the evolution of the Extended Multivariate von Mises distribution during the search run:

Slides

Each frame of this simulation showcases the outcomes of Sequential Quadratic Programming (SQP) minimization applied to a Lennard-Jones system. The system’s energy is defined by the following expression:

   

where the parameters are set as and . Here, represents the ordered pair of molecules and . The simulation involves a system of molecules, each comprising atoms. At the start, a uniform random configuration was generated, with each molecule represented by two center of mass coordinates and one rotational coordinate.

As the simulation progresses, the boundaries of the box are incrementally reduced following each SQP minimization. This effectively simulates an increase in pressure on the system. Notice the hexagonal tiling patches as the simulation advances. These are depicted as blue regular hexagons, each scaled by a factor of 1.93185 and rotated by an angle of 0.17862 relative to the molecules.

It’s important to note that the empty spaces observed in the simulation are a result of the rate at which pressure is increased. A sufficiently slow increase in pressure would eventually lead to a regular tiling.