{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from ase.io import read, write" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# make twobody configurations containing two carbons with distances from 0.01 to 3 A\n", "from ase import Atoms\n", "import numpy as np\n", "\n", "\n", "configs = []\n", "\n", "for d in np.arange(0, 4, 0.04):\n", " atoms = Atoms('OO', positions=[(0, 0, 0), (0, 0, d)])\n", " configs.append(atoms)\n", "\n", "# write('twobody_configs.xyz', configs)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/jhm/efs/test/ajc_testing/miniconda3/envs/macetools-openmm/lib/python3.12/site-packages/e3nn/o3/_wigner.py:10: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", " _Jd, _W3j_flat, _W3j_indices = torch.load(os.path.join(os.path.dirname(__file__), 'constants.pt'))\n", "/home/jhm/efs/test/ajc_testing/software/mace-develop/mace/calculators/mace.py:143: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", " torch.load(f=model_path, map_location=device)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Using head Default out of ['Default']\n", "No dtype selected, switching to float64 to match model dtype.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 0%| | 0/100 [00:00)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 2%|▏ | 2/100 [00:00<00:33, 2.89it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0.2152, 0.2152], device='cuda:0', grad_fn=)\n", "tensor([0.1990, 0.1990], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 9%|▉ | 9/100 [00:01<00:09, 9.23it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0.1819, 0.1819], device='cuda:0', grad_fn=)\n", "tensor([0.1653, 0.1653], device='cuda:0', grad_fn=)\n", "tensor([0.1496, 0.1496], device='cuda:0', grad_fn=)\n", "tensor([0.1349, 0.1349], device='cuda:0', grad_fn=)\n", "tensor([0.1215, 0.1215], device='cuda:0', grad_fn=)\n", "tensor([0.1091, 0.1091], device='cuda:0', grad_fn=)\n", "tensor([0.0978, 0.0978], device='cuda:0', grad_fn=)\n", "tensor([0.0875, 0.0875], device='cuda:0', grad_fn=)\n", "tensor([0.0780, 0.0780], device='cuda:0', grad_fn=)\n", "tensor([0.0692, 0.0692], device='cuda:0', grad_fn=)\n", "tensor([0.0612, 0.0612], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 21%|██ | 21/100 [00:01<00:03, 23.47it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0.0537, 0.0537], device='cuda:0', grad_fn=)\n", "tensor([0.0469, 0.0469], device='cuda:0', grad_fn=)\n", "tensor([0.0406, 0.0406], device='cuda:0', grad_fn=)\n", "tensor([0.0348, 0.0348], device='cuda:0', grad_fn=)\n", "tensor([0.0296, 0.0296], device='cuda:0', grad_fn=)\n", "tensor([0.0248, 0.0248], device='cuda:0', grad_fn=)\n", "tensor([0.0204, 0.0204], device='cuda:0', grad_fn=)\n", "tensor([0.0166, 0.0166], device='cuda:0', grad_fn=)\n", "tensor([0.0132, 0.0132], device='cuda:0', grad_fn=)\n", "tensor([0.0102, 0.0102], device='cuda:0', grad_fn=)\n", "tensor([0.0077, 0.0077], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 33%|███▎ | 33/100 [00:01<00:01, 35.30it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0.0055, 0.0055], device='cuda:0', grad_fn=)\n", "tensor([0.0038, 0.0038], device='cuda:0', grad_fn=)\n", "tensor([0.0025, 0.0025], device='cuda:0', grad_fn=)\n", "tensor([0.0015, 0.0015], device='cuda:0', grad_fn=)\n", "tensor([0.0008, 0.0008], device='cuda:0', grad_fn=)\n", "tensor([0.0003, 0.0003], device='cuda:0', grad_fn=)\n", "tensor([0.0001, 0.0001], device='cuda:0', grad_fn=)\n", "tensor([1.3273e-05, 1.3273e-05], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 45%|████▌ | 45/100 [00:02<00:01, 43.93it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 57%|█████▋ | 57/100 [00:02<00:00, 49.05it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 69%|██████▉ | 69/100 [00:02<00:00, 51.65it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 81%|████████ | 81/100 [00:02<00:00, 52.95it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 87%|████████▋ | 87/100 [00:02<00:00, 53.34it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 100/100 [00:03<00:00, 32.07it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n", "/home/jhm/efs/test/ajc_testing/software/mace-develop/mace/calculators/mace.py:143: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", " torch.load(f=model_path, map_location=device)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Using head Default out of ['Default']\n", "No dtype selected, switching to float64 to match model dtype.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 0%| | 0/100 [00:00)\n", "tensor([0.7194, 0.7194], device='cuda:0', grad_fn=)\n", "tensor([0.6520, 0.6520], device='cuda:0', grad_fn=)\n", "tensor([0.5835, 0.5835], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 10%|█ | 10/100 [00:00<00:02, 35.05it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0.5187, 0.5187], device='cuda:0', grad_fn=)\n", "tensor([0.4593, 0.4593], device='cuda:0', grad_fn=)\n", "tensor([0.4059, 0.4059], device='cuda:0', grad_fn=)\n", "tensor([0.3582, 0.3582], device='cuda:0', grad_fn=)\n", "tensor([0.3158, 0.3158], device='cuda:0', grad_fn=)\n", "tensor([0.2781, 0.2781], device='cuda:0', grad_fn=)\n", "tensor([0.2446, 0.2446], device='cuda:0', grad_fn=)\n", "tensor([0.2146, 0.2146], device='cuda:0', grad_fn=)\n", "tensor([0.1878, 0.1878], device='cuda:0', grad_fn=)\n", "tensor([0.1637, 0.1637], device='cuda:0', grad_fn=)\n", "tensor([0.1420, 0.1420], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 22%|██▏ | 22/100 [00:00<00:01, 45.50it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0.1225, 0.1225], device='cuda:0', grad_fn=)\n", "tensor([0.1048, 0.1048], device='cuda:0', grad_fn=)\n", "tensor([0.0890, 0.0890], device='cuda:0', grad_fn=)\n", "tensor([0.0748, 0.0748], device='cuda:0', grad_fn=)\n", "tensor([0.0620, 0.0620], device='cuda:0', grad_fn=)\n", "tensor([0.0508, 0.0508], device='cuda:0', grad_fn=)\n", "tensor([0.0408, 0.0408], device='cuda:0', grad_fn=)\n", "tensor([0.0322, 0.0322], device='cuda:0', grad_fn=)\n", "tensor([0.0247, 0.0247], device='cuda:0', grad_fn=)\n", "tensor([0.0185, 0.0185], device='cuda:0', grad_fn=)\n", "tensor([0.0133, 0.0133], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 34%|███▍ | 34/100 [00:00<00:01, 48.86it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0.0091, 0.0091], device='cuda:0', grad_fn=)\n", "tensor([0.0059, 0.0059], device='cuda:0', grad_fn=)\n", "tensor([0.0035, 0.0035], device='cuda:0', grad_fn=)\n", "tensor([0.0018, 0.0018], device='cuda:0', grad_fn=)\n", "tensor([0.0008, 0.0008], device='cuda:0', grad_fn=)\n", "tensor([0.0002, 0.0002], device='cuda:0', grad_fn=)\n", "tensor([3.0657e-05, 3.0657e-05], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 46%|████▌ | 46/100 [00:01<00:01, 51.19it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 52%|█████▏ | 52/100 [00:01<00:00, 51.65it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 58%|█████▊ | 58/100 [00:01<00:00, 52.05it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 64%|██████▍ | 64/100 [00:01<00:00, 52.46it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 70%|███████ | 70/100 [00:01<00:00, 52.71it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 76%|███████▌ | 76/100 [00:01<00:00, 53.11it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 88%|████████▊ | 88/100 [00:01<00:00, 53.52it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 100/100 [00:02<00:00, 49.37it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n", "/home/jhm/efs/test/ajc_testing/software/mace-develop/mace/calculators/mace.py:143: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", " torch.load(f=model_path, map_location=device)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Using head Default out of ['Default']\n", "No dtype selected, switching to float64 to match model dtype.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 0%| | 0/100 [00:00)\n", "tensor([4.9579, 4.9579], device='cuda:0', grad_fn=)\n", "tensor([4.1900, 4.1900], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 10%|█ | 10/100 [00:00<00:02, 34.02it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([3.4866, 3.4866], device='cuda:0', grad_fn=)\n", "tensor([2.8870, 2.8870], device='cuda:0', grad_fn=)\n", "tensor([2.3908, 2.3908], device='cuda:0', grad_fn=)\n", "tensor([1.9850, 1.9850], device='cuda:0', grad_fn=)\n", "tensor([1.6540, 1.6540], device='cuda:0', grad_fn=)\n", "tensor([1.3835, 1.3835], device='cuda:0', grad_fn=)\n", "tensor([1.1611, 1.1611], device='cuda:0', grad_fn=)\n", "tensor([0.9771, 0.9771], device='cuda:0', grad_fn=)\n", "tensor([0.8236, 0.8236], device='cuda:0', grad_fn=)\n", "tensor([0.6947, 0.6947], device='cuda:0', grad_fn=)\n", "tensor([0.5855, 0.5855], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 22%|██▏ | 22/100 [00:00<00:01, 44.77it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0.4925, 0.4925], device='cuda:0', grad_fn=)\n", "tensor([0.4129, 0.4129], device='cuda:0', grad_fn=)\n", "tensor([0.3444, 0.3444], device='cuda:0', grad_fn=)\n", "tensor([0.2854, 0.2854], device='cuda:0', grad_fn=)\n", "tensor([0.2345, 0.2345], device='cuda:0', grad_fn=)\n", "tensor([0.1906, 0.1906], device='cuda:0', grad_fn=)\n", "tensor([0.1530, 0.1530], device='cuda:0', grad_fn=)\n", "tensor([0.1209, 0.1209], device='cuda:0', grad_fn=)\n", "tensor([0.0937, 0.0937], device='cuda:0', grad_fn=)\n", "tensor([0.0710, 0.0710], device='cuda:0', grad_fn=)\n", "tensor([0.0522, 0.0522], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 33%|███▎ | 33/100 [00:00<00:01, 48.17it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0.0371, 0.0371], device='cuda:0', grad_fn=)\n", "tensor([0.0251, 0.0251], device='cuda:0', grad_fn=)\n", "tensor([0.0160, 0.0160], device='cuda:0', grad_fn=)\n", "tensor([0.0094, 0.0094], device='cuda:0', grad_fn=)\n", "tensor([0.0049, 0.0049], device='cuda:0', grad_fn=)\n", "tensor([0.0021, 0.0021], device='cuda:0', grad_fn=)\n", "tensor([0.0006, 0.0006], device='cuda:0', grad_fn=)\n", "tensor([7.9475e-05, 7.9475e-05], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 45%|████▌ | 45/100 [00:01<00:01, 51.64it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 57%|█████▋ | 57/100 [00:01<00:00, 52.39it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 63%|██████▎ | 63/100 [00:01<00:00, 52.45it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 75%|███████▌ | 75/100 [00:01<00:00, 52.43it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 87%|████████▋ | 87/100 [00:01<00:00, 52.72it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 100/100 [00:02<00:00, 48.78it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n", "/home/jhm/efs/test/ajc_testing/software/mace-develop/mace/calculators/mace.py:143: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", " torch.load(f=model_path, map_location=device)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Using head Default out of ['Default']\n", "No dtype selected, switching to float64 to match model dtype.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 0%| | 0/100 [00:00)\n", "tensor([9269.6439, 9269.6439], device='cuda:0', grad_fn=)\n", "tensor([1193.9085, 1193.9085], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 10%|█ | 10/100 [00:00<00:02, 34.70it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([359.9671, 359.9671], device='cuda:0', grad_fn=)\n", "tensor([153.7090, 153.7090], device='cuda:0', grad_fn=)\n", "tensor([79.3948, 79.3948], device='cuda:0', grad_fn=)\n", "tensor([46.2294, 46.2294], device='cuda:0', grad_fn=)\n", "tensor([29.2154, 29.2154], device='cuda:0', grad_fn=)\n", "tensor([19.5843, 19.5843], device='cuda:0', grad_fn=)\n", "tensor([13.7165, 13.7165], device='cuda:0', grad_fn=)\n", "tensor([9.9312, 9.9312], device='cuda:0', grad_fn=)\n", "tensor([7.3749, 7.3749], device='cuda:0', grad_fn=)\n", "tensor([5.5828, 5.5828], device='cuda:0', grad_fn=)\n", "tensor([4.2870, 4.2870], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 22%|██▏ | 22/100 [00:00<00:01, 46.00it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([3.3256, 3.3256], device='cuda:0', grad_fn=)\n", "tensor([2.5968, 2.5968], device='cuda:0', grad_fn=)\n", "tensor([2.0346, 2.0346], device='cuda:0', grad_fn=)\n", "tensor([1.5947, 1.5947], device='cuda:0', grad_fn=)\n", "tensor([1.2468, 1.2468], device='cuda:0', grad_fn=)\n", "tensor([0.9695, 0.9695], device='cuda:0', grad_fn=)\n", "tensor([0.7475, 0.7475], device='cuda:0', grad_fn=)\n", "tensor([0.5696, 0.5696], device='cuda:0', grad_fn=)\n", "tensor([0.4272, 0.4272], device='cuda:0', grad_fn=)\n", "tensor([0.3139, 0.3139], device='cuda:0', grad_fn=)\n", "tensor([0.2247, 0.2247], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 34%|███▍ | 34/100 [00:00<00:01, 49.40it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0.1555, 0.1555], device='cuda:0', grad_fn=)\n", "tensor([0.1029, 0.1029], device='cuda:0', grad_fn=)\n", "tensor([0.0642, 0.0642], device='cuda:0', grad_fn=)\n", "tensor([0.0369, 0.0369], device='cuda:0', grad_fn=)\n", "tensor([0.0188, 0.0188], device='cuda:0', grad_fn=)\n", "tensor([0.0079, 0.0079], device='cuda:0', grad_fn=)\n", "tensor([0.0023, 0.0023], device='cuda:0', grad_fn=)\n", "tensor([0.0003, 0.0003], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 46%|████▌ | 46/100 [00:01<00:01, 51.48it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 52%|█████▏ | 52/100 [00:01<00:00, 51.98it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 64%|██████▍ | 64/100 [00:01<00:00, 52.50it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 76%|███████▌ | 76/100 [00:01<00:00, 52.79it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " 88%|████████▊ | 88/100 [00:01<00:00, 53.58it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 100/100 [00:02<00:00, 49.35it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n", "tensor([0., 0.], device='cuda:0', grad_fn=)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "from mace.calculators import MACECalculator\n", "import torch\n", "from tqdm import tqdm\n", "\n", "results= {}\n", "for l in [0.1, 0.2, 0.4, 1.0]:\n", "\n", " calc = MACECalculator(model_paths=\"sclj_stagetwo.model\", device=\"cuda\", lmbda=l, decouple_indices=torch.Tensor([0]))\n", "\n", " dimer_energies = []\n", "\n", " for c in tqdm(configs):\n", " c.set_calculator(calc)\n", " dimer_energies.append(c.get_potential_energy())\n", "\n", " results[str(l)] = dimer_energies\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 0, 'A')" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import scienceplots\n", "plt.style.use([\"science\", \"notebook\"])\n", "from ase.data import covalent_radii\n", "distances = [c.get_distance(0, 1) for c in configs]\n", "cov_radius = covalent_radii[8] + covalent_radii[8]\n", "plt.axvline(cov_radius, color='black', label=\"$r_{cov}$\")\n", "\n", "# y axis log plot\n", "for l, energies in results.items():\n", " plt.plot(distances,energies, label=str(l))\n", "plt.title(\"O-O dimer, sc only\")\n", "plt.ylim(min(energies) - 1, min(energies) + 10)\n", "\n", "plt.legend()\n", "plt.ylabel(\"eV\")\n", "plt.xlabel(\"A\")" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 0, 'A')" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import scienceplots\n", "plt.style.use([\"science\", \"notebook\"])\n", "from ase.data import covalent_radii\n", "distances = [c.get_distance(0, 1) for c in configs]\n", "cov_radius = covalent_radii[8] + covalent_radii[8]\n", "plt.axvline(cov_radius, color='black', label=\"$r_{cov}$\")\n", "\n", "# y axis log plot\n", "# plt.yscale(\"log\")\n", "for l, energies in results.items():\n", " plt.plot(distances,energies, label=str(l))\n", "plt.title(\"O-O dimer, MACE only\")\n", "plt.legend()\n", "plt.ylabel(\"eV\")\n", "plt.xlabel(\"A\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "mace-openmm-dev", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.9" } }, "nbformat": 4, "nbformat_minor": 2 }