Skip to content

Commit f11370c

Browse files
Merge pull request #5 from MatthiasSachs/main-julia-v1.10.8
update to documentation
2 parents 89b6a13 + 60a927f commit f11370c

22 files changed

+336
-83
lines changed

docs/make.jl

Lines changed: 11 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -29,8 +29,17 @@ makedocs(;
2929
"Fitting an Electronic Friction Tensor" => "fitting-eft.md",
3030
"Fitting a Dissipative Particle Dynamics Friction Model" => "fitting-mbdpd.md"
3131
],
32-
"Function Manual" => Any[
33-
"function-manual.md",
32+
# "Importing & Exporting Friction Data" => Any[
33+
# "data-import-export.md",
34+
# ],
35+
# "Function Manual" => Any[
36+
# "function-manual.md"
37+
# ]
38+
"Function Manual" => Any[
39+
"ACEfriction.FrictionModels" => "./function-manual/ACEfriction.FrictionModels.md",
40+
"ACEfriction.MatrixModels" => "./function-manual/ACEfriction.MatrixModels.md",
41+
"ACEfriction.FrictionFit" => "./function-manual/ACEfriction.FrictionFit.md",
42+
"ACEfriction.DataUtils" => "./function-manual/ACEfriction.DataUtils.md"
3443
]
3544
]
3645
)

docs/runLiveServer.jl

Whitespace-only changes.

docs/src/data-import-export.md

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
# Friction Data
2+
3+
To train a friction tensor model in ACEfriciton.jl, friction data
4+
$D = (R_i,\Gamma_i)_{i=1}^{N_{\rm obs}}$ comprised of atomic configurations, $R_i$, and a friction tensors, $\Gamma_i$ is required.
5+
6+
`ACEfriction.jl` implements the structure `FrictionData` to store and manipulate single observations $(R_i,\Gamma_i)$ in the pre-training phase:
7+
```julia
8+
struct FrictionData
9+
atoms
10+
friction_tensor
11+
friction_indices
12+
end
13+
```
14+
where
15+
- `atoms` -- stores data of the atomic configuration ans is assumed to be of type `JuLIP.Atoms`,
16+
- `friction_tensor` -- stores data on the friction tensor and is assumed to be of type`SparseMatrix{SMatrix{3, 3, T, 9}}`, where `T<:Float` and `Ti<:Int`. That is, the friction tensor is stored in the form of sparse matrices with $3 \times 3$-matrix valued block entries,
17+
-`friction_indices` -- is a one-dimensional integer array, which contains all atom indices for which the friction tensor is defined.
18+
19+
# Importing & Exporting Friction Data
20+
21+
`ACEfriction.DataUtils` implements the function [`save_h5fdata(rdata::Vector{FrictionData}, filename::String)`](@ref) to save arrays of friction data to a custom costum formatted `hdf5` file, as well as the function [`load_h5fdata(filename::String)`](@ref) to load friction data from such costum formatted `hdf5` files.
22+
23+
24+
# Custom HDF5 File Format for Friction Data
25+
26+
The hierachical structure of such hdf5 files is as follows:
27+
28+
Each observation $(R_i,\Gamma_i)$ is saved in a separate group in named by respective index $i$, i.e., we have the following groups on root level of the hdf5 file:
29+
```
30+
├─ 📂 1
31+
├─ 📂 2
32+
├─ 📂 3
33+
│ :
34+
├─ 📂 N_obs
35+
```
36+
Within each of these groups, the data of the respective atomic configuration $R_i$ and friction tensor $\Gamma_i$ are saved in the subgroups `atoms` and `friction_tensor`, respectively:
37+
```
38+
├─ 📂 i # Index of data point
39+
├─ 📂 atoms # Atom configuration data
40+
│ ├─ 🔢 atypes
41+
│ ├─ 🔢 cell
42+
│ │ └─ 🏷️ column_major
43+
│ ├─ 🔢 pbc
44+
│ └─ 🔢 positions
45+
│ └─ 🏷️ column_major
46+
└─ 📂 friction_tensor # Friction tensor data
47+
├─ 🔢 ft_I
48+
├─ 🔢 ft_J
49+
├─ 🔢 ft_mask
50+
└─ 🔢 ft_val,
51+
└─ 🏷️ column_major
52+
```
53+
54+
[Datasets](https://support.hdfgroup.org/documentation/hdf5/latest/_h5_d__u_g.html) in the group `atoms` store the equivalent information provided by the attributes `positions`, `numbers`, `cell`, and `pbc` of [atoms objects](https://wiki.fysik.dtu.dk/ase/ase/atoms.html), i.e.,
55+
an atomic configuration of N atoms is described by the following datasets contained in the group `atoms`:
56+
- `atypes` -- A one-dimensional Integer dataset of length N. The ith entry corresponds to the atomic element number of the ith atom in the configuration. (Note: `types` corresponds to the atoms attribute `numbers` in the ase.)
57+
- `cell` -- A two-dimensional Float64 dataset of size 3 x 3.
58+
- `pbc` -- A one-dimensional Integer array of length 3 indicating the periodicity properties of the xyz dimension, e.g., `pbc = [1,0,0]` describes periodic boundary conditions in x dimension and non-periodic boundary conditions in the y and z dimensions.
59+
- `positions` -- A two-dimensional Float64 dataset of size n N x 3. The ith column corresponds to the position of the ith atom in the configuration
60+
61+
[Datasets](https://support.hdfgroup.org/documentation/hdf5/latest/_h5_d__u_g.html) in the group `friction_tensor` store the friction tensor as a N x N sparse matrix with 3x3 valued block entries, i.e., a friction tensor with m non-zero 3x3 blocks is stored
62+
- `ft_I` -- A one-dimensional Integer dataset of length m specifying the column indices of non-zero block entries of the friction tensor.
63+
- `ft_J` -- A one-dimensional Integer dataset of length m specifying the row indices of non-zero block entries of the friction tensor.
64+
- `ft_val` -- A three-dimensional Float64 dataset of size m x 3 x 3 specifying the values of the non-zero 3 x 3 block entries of the friction tensor. For example, the 3 x 3 array `ft_val[k,:,:]` corresponds to the 3 x 3 block entry of the friction tensor with column index `ft_I[k]`, and row index `ft_J[k]`.
65+
- `ft_mask` -- A one-dimensional Integer dataset/list containg the indices of atoms for which friction information is provided.
66+
67+
68+
!!! note
69+
All two or three-dimensional datasets in the groups `atoms` have an additional attribute `column_major`. If the hdf5 file is created in a language that stores matrices in column-major form (e.g., julia), this attribute must be set to 1 (True). If the hdf5 file is created in a language that stores matrices in column-major form (e.g., python), this attribute must be set to 0 (False).
70+
71+

docs/src/fitting-eft.md

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33
In this workflow example we demonstrate how `ACEfriction.jl` can be used to fit a simple 6 x 6 Electronic friction tensor modeling the non-adiabitic interactions of a hydrogen-atom on a copper surface.
44

55
## Load Electronic Friction Tensor Data
6-
We first use the function [load_h5fdata]() to load the data of friction tensors from a [custom-formated]() hdf5 file and convert the data to the internal data format [FrictionData].
6+
We first use the function [load_h5fdata](@ref) to load the data of friction tensors from a [custom-formated](@ref costum-hdf5-format) hdf5 file and convert the data to the internal data format [FrictionData](@ref friction-data-representation).
77
```julia
88
using ACEfriction
99
# Load data
@@ -12,8 +12,8 @@ rdata = ACEfriction.DataUtils.load_h5fdata( "./test/test-data-100.h5");
1212
n_train = Int(ceil(.8 * length(rdata)))
1313
n_test = length(rdata) - n_train
1414
# Partition data into train and test set and convert the data
15-
fdata = Dict("train" => FrictionData.(rdata[1:n_train]),
16-
"test"=> FrictionData.(rdata[n_train+1:end]));
15+
fdata = Dict("train" => rdata[1:n_train],
16+
"test"=> rdata[n_train+1:end]);
1717
```
1818

1919
## Specify the Friction Model
@@ -46,7 +46,7 @@ To train our model we first extract the parameters from the friction model, whic
4646
c=params(fm)
4747
ffm = FluxFrictionModel(c)
4848
```
49-
Next, the function `flux_assemble` is used to prepare data for training. This includes evaluating the ACE-basis functions of the matrix models in `fm` on all configurations in the data set. Since the loss function of our model is quartic polynomial in the parameters, we don't need to reevaluate the ACE-basis functions at later stages of the training process.
49+
Next, the function [`flux_assemble`]() is used to prepare data for training. This includes evaluating the ACE-basis functions of the matrix models in `fm` on all configurations in the data set. Since the loss function of our model is quartic polynomial in the parameters, we don't need to reevaluate the ACE-basis functions at later stages of the training process.
5050
```julia
5151
flux_data = Dict( "train"=> flux_assemble(fdata["train"], fm, ffm; ),
5252
"test"=> flux_assemble(fdata["test"], fm, ffm));

docs/src/fitting-mbdpd.md

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -34,8 +34,8 @@ The following code loads training and test data comprised of particle configurat
3434
rdata_train = ACEfriction.DataUtils.load_h5fdata("./examples/data/dpd-train-x.h5");
3535
rdata_test = ACEfriction.DataUtils.load_h5fdata("./examples/data/dpd-train-x.h5");
3636

37-
fdata = Dict("train" => FrictionData.(rdata_train),
38-
"test"=> FrictionData.(rdata_test));
37+
fdata = Dict("train" => rdata_train,
38+
"test"=> rdata_test);
3939
(n_train, n_test) = length(fdata["train"]), length(fdata["test"])
4040
```
4141
Here the training data is contains friction tensors of 50 configurations each comprised of 64 particles, and the test data contains friction tensors of 10 configurations each comprised of 216 particles. The underlying friction tensors were synthetically generated using the following simple friction model, which is a smooth version of the standard heuristic DPD friction models commonly used in simulations:
Lines changed: 85 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,85 @@
1+
```@meta
2+
CurrentModule = ACEfriction.DataUtils
3+
```
4+
5+
The submodule `ACEfriction.DataUtils.jl` provides structures to internally store friction data in `ACEfriction.jl` and functions to import and export friction data from and to custom formatted hdf5 files.
6+
7+
8+
### [Friction Data representation](@id friction-data-representation)
9+
10+
For pre-training storage and manipulation of friction data,
11+
`ACEfriction.jl` implements the structure `FrictionData` to represent a single observation $(R_i,\Gamma_i)$ of an atomic configuration $R_i$ and corresponding friction tensor $\Gamma_i$:
12+
```julia
13+
struct FrictionData
14+
atoms
15+
friction_tensor
16+
friction_indices
17+
end
18+
```
19+
where
20+
- `atoms` -- stores data of the atomic configuration ans is assumed to be of type `JuLIP.Atoms`,
21+
- `friction_tensor` -- stores data on the friction tensor and is assumed to be of type`SparseMatrix{SMatrix{3, 3, T, 9}}`, where `T<:Float` and `Ti<:Int`. That is, the friction tensor is stored in the form of sparse matrices with $3 \times 3$-matrix valued block entries,
22+
- `friction_indices` -- is a one-dimensional integer array, which contains all atom indices for which the friction tensor is defined.
23+
24+
### Importing & Exporting Friction Data
25+
26+
`ACEfriction.DataUtils` implements the function [`save_h5fdata`](@ref) to save arrays of friction data to a [custom formatted](@ref costum-hdf5-format) `hdf5` file, as well as the function [`load_h5fdata`](@ref) to load friction data from such costum formatted `hdf5` files:
27+
28+
```@docs
29+
save_h5fdata
30+
```
31+
32+
```@docs
33+
load_h5fdata
34+
```
35+
36+
37+
### [Custom HDF5 File Format for Friction Data](@id costum-hdf5-format)
38+
39+
The hierachical structure of such hdf5 files is as follows:
40+
41+
Each observation $(R_i,\Gamma_i)$ is saved in a separate group in named by respective index $i$, i.e., we have the following groups on root level of the hdf5 file:
42+
```
43+
├─ 📂 1
44+
├─ 📂 2
45+
├─ 📂 3
46+
│ :
47+
├─ 📂 N_obs
48+
```
49+
Within each of these groups, the data of the respective atomic configuration $R_i$ and friction tensor $\Gamma_i$ are saved in the subgroups `atoms` and `friction_tensor`, respectively:
50+
```
51+
├─ 📂 i # Index of data point
52+
├─ 📂 atoms # Atom configuration data
53+
│ ├─ 🔢 atypes
54+
│ ├─ 🔢 cell
55+
│ │ └─ 🏷️ column_major
56+
│ ├─ 🔢 pbc
57+
│ └─ 🔢 positions
58+
│ └─ 🏷️ column_major
59+
└─ 📂 friction_tensor # Friction tensor data
60+
├─ 🔢 ft_I
61+
├─ 🔢 ft_J
62+
├─ 🔢 ft_mask
63+
└─ 🔢 ft_val,
64+
└─ 🏷️ column_major
65+
```
66+
67+
[Datasets](https://support.hdfgroup.org/documentation/hdf5/latest/_h5_d__u_g.html) in the group `atoms` store the equivalent information provided by the attributes `positions`, `numbers`, `cell`, and `pbc` of [atoms objects](https://wiki.fysik.dtu.dk/ase/ase/atoms.html), i.e.,
68+
an atomic configuration of N atoms is described by the following datasets contained in the group `atoms`:
69+
- `atypes` -- A one-dimensional Integer dataset of length N. The ith entry corresponds to the atomic element number of the ith atom in the configuration. (Note: `types` corresponds to the atoms attribute `numbers` in the ase.)
70+
- `cell` -- A two-dimensional Float64 dataset of size 3 x 3.
71+
- `pbc` -- A one-dimensional Integer array of length 3 indicating the periodicity properties of the xyz dimension, e.g., `pbc = [1,0,0]` describes periodic boundary conditions in x dimension and non-periodic boundary conditions in the y and z dimensions.
72+
- `positions` -- A two-dimensional Float64 dataset of size n N x 3. The ith column corresponds to the position of the ith atom in the configuration
73+
74+
[Datasets](https://support.hdfgroup.org/documentation/hdf5/latest/_h5_d__u_g.html) in the group `friction_tensor` store the friction tensor as a N x N sparse matrix with 3x3 valued block entries, i.e., a friction tensor with m non-zero 3x3 blocks is stored
75+
- `ft_I` -- A one-dimensional Integer dataset of length m specifying the column indices of non-zero block entries of the friction tensor.
76+
- `ft_J` -- A one-dimensional Integer dataset of length m specifying the row indices of non-zero block entries of the friction tensor.
77+
- `ft_val` -- A three-dimensional Float64 dataset of size m x 3 x 3 specifying the values of the non-zero 3 x 3 block entries of the friction tensor. For example, the 3 x 3 array `ft_val[k,:,:]` corresponds to the 3 x 3 block entry of the friction tensor with column index `ft_I[k]`, and row index `ft_J[k]`.
78+
- `ft_mask` -- A one-dimensional Integer dataset/list containg the indices of atoms for which friction information is provided.
79+
80+
81+
!!! warning
82+
All two or three-dimensional datasets in the groups `atoms` and `friction_tensor` have an additional attribute `column_major`. If the hdf5 file is created in a language that stores matrices in column-major form (e.g., julia), this attribute must be set to 1 (True). If the hdf5 file is created in a language that stores matrices in column-major form (e.g., python), this attribute must be set to 0 (False).
83+
84+
85+
Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
```@meta
2+
CurrentModule = ACEfriction.FrictionFit
3+
```
4+
5+
```@docs
6+
flux_assemble
7+
```
8+
```@docs
9+
FluxFrictionModel
10+
```
11+
12+
```@docs
13+
get_ids
14+
```
15+
```@docs
16+
l2_loss
17+
```
18+
```@docs
19+
weighted_l2_loss
20+
```
21+
```@docs
22+
weighted_l1_loss
23+
```

docs/src/function-manual.md renamed to docs/src/function-manual/ACEfriction.FrictionModels.md

Lines changed: 0 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,3 @@
1-
# Function Manual (@id Function-Manual)
2-
3-
## ACEfriction.FrictionModels.jl
4-
51
```@meta
62
CurrentModule = ACEfriction.FrictionModels
73
```
@@ -47,8 +43,3 @@ set_params!
4743
```@docs
4844
set_zero!
4945
```
50-
51-
## ACEfriction.MatrixModels.jl
52-
53-
54-
## ACEfriction.FrictionFit.jl
Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
```@meta
2+
CurrentModule = ACEfriction.MatrixModels
3+
```
4+
5+
```@docs
6+
RWCMatrixModel
7+
```
8+
```@docs
9+
PWCMatrixModel
10+
```
11+
```@docs
12+
OnsiteOnlyMatrixModel
13+
```
14+
```@docs
15+
mbdpd_matrixmodel
16+
```

docs/src/index.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@
22

33
The julia package `ACEfriction.jl` facilitates simulation and machine learning of configuration-dependent friction tensor models from data. The models are based on an equivariant Atomic Cluster Expansion (ACE) and, as such, are computationally highly efficient and size transferable. The underlying framework of model construction is described in detail in [Sachs et al., (2024)](@ref ACEfriction-paper).
44

5-
For a quick start, we recommend reading the [Installation Instructions](installation.md) and the [Overview](overview.md) section, followed by the [Workflow Examples](fitting-eft.md). Detailed documentation of front-end-facing functions can be found in the [Function Manual](function-manual.md).
5+
For a quick start, we recommend reading the [Installation Instructions](installation.md) and the [Overview](overview.md) section, followed by the [Workflow Examples](fitting-eft.md). Detailed documentation of front-end-facing functions can be found in the Function Manual.
66

77

88
### [References](@id ACEfriction-paper)

0 commit comments

Comments
 (0)