<!– This one is a work in progress –>
[deps]
+Environment · BcdiDocs Environment
<!– This one is a work in progress –>
[deps]
BcdiAtomic = "a97cdeff-3185-4906-97ce-92639738da6c"
-BcdiSimulate = "b133d2d9-b23b-44ee-be6b-5f897f6a3084"
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
<!– 
–> 
<!– 
–>
Bragg Coherent Diffraction Imaging (BCDI) Core implements some of the core functionality used for future projects BcdiAtomic.jl (an atomic scale BCDI solver), BcdiMeso.jl (a mesoscale BCDI Solver), BcdiMulti.jl (a multiscale BCDI solver), BcdiTrad.jl (a BCDI solver using projection algorithms), and BcdiStrain (a BCDI solver for mesoscale using projection algorithms). BcdiCore.jl implements the loss functions and derivatives of loss functions used in these packages.
While this package is marked as BCDI specific, the methods are more general and can be used in many phase retrieval problems. In the future, this package may be incorporated into a more general phase retrieval core package.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
Currently, BcdiCore.jl is not registered in the Julia general registry and can be installed by running in the REPL package manager (]):
add BcdiCore
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
<!– –> <!– –>
Bragg Coherent Diffraction Imaging (BCDI) Core implements some of the core functionality used for future projects BcdiAtomic.jl (an atomic scale BCDI solver), BcdiMeso.jl (a mesoscale BCDI Solver), BcdiMulti.jl (a multiscale BCDI solver), BcdiTrad.jl (a BCDI solver using projection algorithms), and BcdiStrain (a BCDI solver for mesoscale using projection algorithms). BcdiCore.jl implements the loss functions and derivatives of loss functions used in these packages.
While this package is marked as BCDI specific, the methods are more general and can be used in many phase retrieval problems. In the future, this package may be incorporated into a more general phase retrieval core package.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
Currently, BcdiCore.jl is not registered in the Julia general registry and can be installed by running in the REPL package manager (]):
add BcdiCore
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
The BYU-CXI research group maintains a suite of Julia packages to solve the Bragg Coherent Diffraction Imaging (BCDI) problem in several different regimes and circumstance.
BcdiCore.jl implements all of the Fourier transforms for the Julia BCDI packages. In addition, BcdiCore calculates the loss function used (either $L_2$ or the MLE estimator) and derivatives of these loss functions.
BcdiTrad.jl implements projection-based BCDI algorithm. Currently, this is limited to ER, HIO, and shrinkwrap.
BcdiStrain.jl implements a multi-peak BCDI algorithm developed by the BYU-CXI group. In addition to the alogrithms present in BcdiTrad, BcdiStrain also implements Mount, an operator that switches between peaks.
BcdiMeso.jl implements a BCDI algorithm that solves in the mesoscale regime. Instead of using projections, this algorithm uses a gradient-based optimization scheme. Additionally, BcdiMeso does not assume a small measurement distance away from the peak.
BcdiAtomic.jl is an upcoming BCDI package that implements a BCDI algorithm that solves at the atomic scale.
BcdiMulti.jl is an upcoming BCDI package that implements a multiscale BCDI algorithm that solves at both the mesoscale and the atomic scale.
BcdiSimulate.jl is an upcoming BCDI package that simulates the BCDI problem. Currently, this is only implimented at the atomic scale.
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
Bragg Coherent Diffraction Imaging (BCDI) Core implements some of the core functionality used for the Julia BCDI packages BcdiCore.jl implements the loss functions and derivatives of loss functions used in these packages.
While this package is marked as BCDI specific, the methods are more general and can be used in many phase retrieval problems. In the future, this package may be incorporated into a more general phase retrieval core package.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
BcdiCore.jl is registered in the Julia general registry and can be installed by running in the REPL package manager (]):
add BcdiCore
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Bragg Coherent Diffraction Imaging (BCDI) Core implements some of the core functionality used for future projects BcdiAtomic.jl (an atomic scale BCDI solver), BcdiMeso.jl (a mesoscale BCDI Solver), BcdiMulti.jl (a multiscale BCDI solver), BcdiTrad.jl (a BCDI solver using projection algorithms), and BcdiStrain (a BCDI solver for mesoscale using projection algorithms). BcdiCore.jl implements the loss functions and derivatives of loss functions used in these packages.
While this package is marked as BCDI specific, the methods are more general and can be used in many phase retrieval problems. In the future, this package may be incorporated into a more general phase retrieval core package.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
Currently, BcdiCore.jl is not registered in the Julia general registry and can be installed by running in the REPL package manager (]):
add BcdiCore
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
For the atomic model, $G(u)$ is defined as
\[G(h,k,l) = \sum_j e^{-i (x_j (h+G_h) + y_j (k+G_k) + z_j (l+G_l))} \\\]
where $x_j, y_j, z_j$ are atom positions and $h,k,l$ represent a distance away from some scattering vector $G_h, G_k, G_l$ in reciprocal space. It is important that the $h,k,l$ value are integers and that they range from $-\frac{n}{2} \to \frac{n}{2}-1$, so both real space and reciprocal space positions must be scaled. The $x_j,y_j,z_j$ positions should be shifted to lie between $0 \to 1$ and should be multiplied by $2\pi$ to capture the missing $2 \pi$ scaling in the Fourier transform exponent.
Calculating the loss function and its derivative for the atomic model is done in three steps. First, the BcdiCore.AtomicState struct is created. Then, the atom positions are set by calling BcdiCore.setpts!. Finally, the loss function is calculated with BcdiCore.loss.
state = AtomicState(lossType, scale, intens, G, h, k, l)
+Atomic Models · BcdiDocs Mathematical Definitions
For the atomic model, $G(u)$ is defined as
\[G(h,k,l) = \sum_j e^{-i (x_j (h+G_h) + y_j (k+G_k) + z_j (l+G_l))} \\\]
where $x_j, y_j, z_j$ are atom positions and $h,k,l$ represent a distance away from some scattering vector $G_h, G_k, G_l$ in reciprocal space. It is important that the $h,k,l$ value are integers and that they range from $-\frac{n}{2} \to \frac{n}{2}-1$, so both real space and reciprocal space positions must be scaled. The $x_j,y_j,z_j$ positions should be shifted to lie between $0 \to 1$ and should be multiplied by $2\pi$ to capture the missing $2 \pi$ scaling in the Fourier transform exponent.
Usage
Calculating the loss function and its derivative for the atomic model is done in three steps. First, the BcdiCore.AtomicState struct is created. Then, the atom positions are set by calling BcdiCore.setpts!. Finally, the loss function is calculated with BcdiCore.loss.
state = AtomicState(lossType, scale, intens, G, h, k, l)
setpts!(state, x, y, z, getDeriv)
-lossVal = loss(state, getDeriv, getLoss)
If the derivative is requested with the getDeriv variable, the results are stored in state.xDeriv, state.yDeriv, and state.zDeriv.
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
If the derivative is requested with the getDeriv variable, the results are stored in state.xDeriv, state.yDeriv, and state.zDeriv.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Similar to the atomic model, $G(u)$ is initially defined as
\[G(h,k,l) = \sum_j e^{-i (x'_j (h+G_h) + y'_j (k+G_k) + z'_j (l+G_l))} \\\]
where $x'_j, y'_j, z'_j$ are atom positions and $h,k,l$ represent a distance away from some scattering vector $G_h, G_k, G_l$ in reciprocal space. However, $x'_j, y'_j, z'_j$ can be thought of as an addition of lattice spacings and displacement vectors, i.e. $x_j+ux_j, y_j+uy_j, z_j+uz_j$. Then, if $G_h,G_k,G_l$ are reciprocal lattice vectors, we find that $x \cdot G$ is an integer multiple of $2\pi$, so it does not affect the simulated electric field. We are then left with
\[G(h,k,l) = \sum_j e^{-i (x_j G_h + y_j G_k + uz_j G_l)} e^{-i (ux_j (h+G_h) + uy_j (k+G_k) + uz_j (l+G_l))} \\\]
Coarse graining to get a mesoscale model, we get
\[G(h,k,l) = \sum_j \rho_j e^{-i (x_j h + y_j k + uz_j l)} e^{-i (ux_j (h+G_h) + uy_j (k+G_k) + uz_j (l+G_l))} \\\]
Again, it is important that the $h,k,l$ value are integers and that they range from $-\frac{n}{2} \to \frac{n}{2}-1$, so both real space and reciprocal space positions must be scaled. The $x'_j,y'_j,z'_j$ positions should be shifted to lie between $0 \to 1$ and should be multiplied by $2\pi$ to capture the missing $2 \pi$ scaling in the Fourier transform exponent.
Calculating the loss function and its derivative for the mesoscale model is done in three steps. First, the BcdiCore.MesoState struct is created. Then, the atom positions are set by calling BcdiCore.setpts!. Finally, the loss function is calculated with BcdiCore.loss.
state = MesoState(lossType, scale, intens, G, h, k, l)
+Mesoscale Models · BcdiDocs Mathematical Definitions
Similar to the atomic model, $G(u)$ is initially defined as
\[G(h,k,l) = \sum_j e^{-i (x'_j (h+G_h) + y'_j (k+G_k) + z'_j (l+G_l))} \\\]
where $x'_j, y'_j, z'_j$ are atom positions and $h,k,l$ represent a distance away from some scattering vector $G_h, G_k, G_l$ in reciprocal space. However, $x'_j, y'_j, z'_j$ can be thought of as an addition of lattice spacings and displacement vectors, i.e. $x_j+ux_j, y_j+uy_j, z_j+uz_j$. Then, if $G_h,G_k,G_l$ are reciprocal lattice vectors, we find that $x \cdot G$ is an integer multiple of $2\pi$, so it does not affect the simulated electric field. We are then left with
\[G(h,k,l) = \sum_j e^{-i (x_j G_h + y_j G_k + uz_j G_l)} e^{-i (ux_j (h+G_h) + uy_j (k+G_k) + uz_j (l+G_l))} \\\]
Coarse graining to get a mesoscale model, we get
\[G(h,k,l) = \sum_j \rho_j e^{-i (x_j h + y_j k + uz_j l)} e^{-i (ux_j (h+G_h) + uy_j (k+G_k) + uz_j (l+G_l))} \\\]
Again, it is important that the $h,k,l$ value are integers and that they range from $-\frac{n}{2} \to \frac{n}{2}-1$, so both real space and reciprocal space positions must be scaled. The $x'_j,y'_j,z'_j$ positions should be shifted to lie between $0 \to 1$ and should be multiplied by $2\pi$ to capture the missing $2 \pi$ scaling in the Fourier transform exponent.
Usage
Calculating the loss function and its derivative for the mesoscale model is done in three steps. First, the BcdiCore.MesoState struct is created. Then, the atom positions are set by calling BcdiCore.setpts!. Finally, the loss function is calculated with BcdiCore.loss.
state = MesoState(lossType, scale, intens, G, h, k, l)
setpts!(state, x, y, z, rho, ux, uy, uz, getDeriv)
-lossVal = loss(state, getDeriv, getLoss)
If the derivative is requested with the getDeriv variable, the results are stored in state.rhoDeriv, state.uxDeriv, state.uyDeriv, and state.uzDeriv.
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
If the derivative is requested with the getDeriv variable, the results are stored in state.rhoDeriv, state.uxDeriv, state.uyDeriv, and state.uzDeriv.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
The multiscale model is a combination of an atomic scale and a mesoscale model. In this case, $G(h,k,l)$ is defined as
\[G(h,k,l) = G_a(h,k,l) + G_m(h,k,l)\]
where $a$ signifies the atomic model and $m$ signifies the mesoscale model.
Calculating the loss function and its derivative for the mesoscale model is done in three steps. First, the BcdiCore.MultiState struct is created. Then, the atom positions are set by calling BcdiCore.setpts!. Finally, the loss function is calculated with BcdiCore.loss.
state = MultiState(lossType, scale, intens, G, h, k, l)
+Multiscale Models · BcdiDocs Mathematical Definitions
The multiscale model is a combination of an atomic scale and a mesoscale model. In this case, $G(h,k,l)$ is defined as
\[G(h,k,l) = G_a(h,k,l) + G_m(h,k,l)\]
where $a$ signifies the atomic model and $m$ signifies the mesoscale model.
Usage
Calculating the loss function and its derivative for the mesoscale model is done in three steps. First, the BcdiCore.MultiState struct is created. Then, the atom positions are set by calling BcdiCore.setpts!. Finally, the loss function is calculated with BcdiCore.loss.
state = MultiState(lossType, scale, intens, G, h, k, l)
setpts!(state, x, y, z, mx, my, mz, rho, ux, uy, uz, getDeriv)
-lossVal = loss(state, getDeriv, getLoss)
Here x, y, z are atomic positions and mx, my, mz are the real space locations of the mesoscale model.
If the derivative is requested with the getDeriv variable, the results are stored in state.xDeriv, state.yDeriv, and state.zDeriv, state.rhoDeriv, state.uxDeriv, state.uyDeriv, and state.uzDeriv.
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
Here x, y, z are atomic positions and mx, my, mz are the real space locations of the mesoscale model.
If the derivative is requested with the getDeriv variable, the results are stored in state.xDeriv, state.yDeriv, and state.zDeriv, state.rhoDeriv, state.uxDeriv, state.uyDeriv, and state.uzDeriv.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
In general, BcdiCore.jl will be called by developers of phase retrieval codes, not end users. BcdiCore.jl implements loss functions and derivatives of loss functions for atomic models, mesoscale models, multiscale models, and traditional projection-based methods.
Currently, BcdiCore.jl implements two types of losses, the average $L_2$ norm and the average log-likelihood.
Explicitly, the average $L_2$ loss is defined as
\[L_2 = \frac{1}{N} \sum_u \left( \lvert G(u) \rvert - \lvert F(u) \rvert \right)^2\]
where $G(u)$ is the simulated electric field, $\lvert F(u) \rvert^2$ is the measured intensity at a point $u$ in reciprocal space, and $N$ is the total number of meaurement points.
The average log-likelihood (for the Poisson distribution) is defined as
\[\ell = \frac{1}{N} \sum_u \lvert G(u) \rvert^2 - \lvert F(u) \rvert^2 \ln{\left(\lvert G(u) \rvert^2 \right)}\]
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
In general, BcdiCore.jl will be called by developers of phase retrieval codes, not end users. BcdiCore.jl implements loss functions and derivatives of loss functions for atomic models, mesoscale models, multiscale models, and traditional projection-based methods.
Currently, BcdiCore.jl implements two types of losses, the average $L_2$ norm and the average log-likelihood.
Explicitly, the average $L_2$ loss is defined as
\[L_2 = \frac{1}{N} \sum_u \left( \lvert G(u) \rvert - \lvert F(u) \rvert \right)^2\]
where $G(u)$ is the simulated electric field, $\lvert F(u) \rvert^2$ is the measured intensity at a point $u$ in reciprocal space, and $N$ is the total number of meaurement points.
The average log-likelihood (for the Poisson distribution) is defined as
\[\ell = \frac{1}{N} \sum_u \lvert G(u) \rvert^2 - \lvert F(u) \rvert^2 \ln{\left(\lvert G(u) \rvert^2 \right)}\]
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Similar to the mesoscale model, $G(u)$ is initially defined as
\[G(h,k,l) = \sum_j \rho_j e^{-i (x_j h + y_j k + uz_j l)} e^{-i (ux_j (h+G_h) + uy_j (k+G_k) + uz_j (l+G_l))} \\\]
where $x_j, y_j, z_j$ are real space positions, $ux_j, uy_j, uz_j$ are diplacement vectors, and $h,k,l$ represent a distance away from some scattering vector $G_h, G_k, G_l$ in reciprocal space. However, we assume that, because the distance from the scattering vector and the displacement vectors are small, $u \cdot h$ is negligible. So we are left with
\[G(h,k,l) = \sum_j \rho_j e^{-i (x_j h + y_j k + uz_j l)} e^{-i (ux_j G_h + uy_j G_k + uz_j G_l)} \\\]
Then, we combine the entire $\rho_j e^{-i (ux_j G_h + uy_j G_k + uz_j G_l)}$ quantity as one variable and get
\[G(h,k,l) = \sum_j \psi_j e^{-i (x_j h + y_j k + uz_j l)} \\\]
In this case, this is an ordinary Fourier transform, so we put the factor of $2\pi$ back into $G(h,k,l)$ to get
\[G(h,k,l) = \sum_j \psi_j e^{-2 \pi i (x_j h + y_j k + uz_j l)} \\\]
Calculating the loss function and its derivative for the traditional model is done in two steps. First, the BcdiCore.TradState struct is created. Then, the loss function is calculated with BcdiCore.loss.
state = TradState(losstype, scale, intens, realSpace)
-lossVal = loss(state, getDeriv, getLoss)If the derivative is requested with the getDeriv variable, the result us stored in state.deriv.
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
Similar to the mesoscale model, $G(u)$ is initially defined as
\[G(h,k,l) = \sum_j \rho_j e^{-i (x_j h + y_j k + uz_j l)} e^{-i (ux_j (h+G_h) + uy_j (k+G_k) + uz_j (l+G_l))} \\\]
where $x_j, y_j, z_j$ are real space positions, $ux_j, uy_j, uz_j$ are diplacement vectors, and $h,k,l$ represent a distance away from some scattering vector $G_h, G_k, G_l$ in reciprocal space. However, we assume that, because the distance from the scattering vector and the displacement vectors are small, $u \cdot h$ is negligible. So we are left with
\[G(h,k,l) = \sum_j \rho_j e^{-i (x_j h + y_j k + uz_j l)} e^{-i (ux_j G_h + uy_j G_k + uz_j G_l)} \\\]
Then, we combine the entire $\rho_j e^{-i (ux_j G_h + uy_j G_k + uz_j G_l)}$ quantity as one variable and get
\[G(h,k,l) = \sum_j \psi_j e^{-i (x_j h + y_j k + uz_j l)} \\\]
In this case, this is an ordinary Fourier transform, so we put the factor of $2\pi$ back into $G(h,k,l)$ to get
\[G(h,k,l) = \sum_j \psi_j e^{-2 \pi i (x_j h + y_j k + uz_j l)} \\\]
Calculating the loss function and its derivative for the traditional model is done in two steps. First, the BcdiCore.TradState struct is created. Then, the loss function is calculated with BcdiCore.loss.
state = TradState(losstype, scale, intens, realSpace)
+lossVal = loss(state, getDeriv, getLoss)If the derivative is requested with the getDeriv variable, the result us stored in state.deriv.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
<!– 
–>
Bragg Coherent Diffraction Imaging (BCDI) Meso (Mesoscale) implements phase retrieval for mesoscale models with stochastic gradient descent. Some of the core functionality of this project is implemented in BcdiCore.jl. Additionally, this package is part of a collection of BCDI packages consisting of BcdiAtomic.jl (an atomic scale BCDI solver), BcdiMeso.jl (a mesoscale BCDI Solver), and BcdiMulti.jl (a multiscale BCDI solver).
While this package is marked as BCDI specific, the methods are more general and can be used in many phase retrieval problems. In the future, this package may be incorporated into a more general phase retrieval package.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
Currently, BcdiStrain.jl is not registered in the Julia general registry. BcdiTrad.jl can be installed by running in the REPL package manager (]):
add BcdiMesoSettings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
<!– –>
Bragg Coherent Diffraction Imaging (BCDI) Meso (Mesoscale) implements phase retrieval for mesoscale models with stochastic gradient descent. Some of the core functionality of this project is implemented in BcdiCore.jl. Additionally, this package is part of a collection of BCDI packages consisting of BcdiAtomic.jl (an atomic scale BCDI solver), BcdiMeso.jl (a mesoscale BCDI Solver), and BcdiMulti.jl (a multiscale BCDI solver).
While this package is marked as BCDI specific, the methods are more general and can be used in many phase retrieval problems. In the future, this package may be incorporated into a more general phase retrieval package.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
Currently, BcdiStrain.jl is not registered in the Julia general registry. BcdiTrad.jl can be installed by running in the REPL package manager (]):
add BcdiMesoSettings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Bragg Coherent Diffraction Imaging (BCDI) Meso (Mesoscale) implements phase retrieval for mesoscale models with stochastic gradient descent.
While this package is marked as BCDI specific, the methods are more general and can be used in many phase retrieval problems. In the future, this package may be incorporated into a more general phase retrieval package.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
BcdiStrain.jl is registered in the Julia general registry and can be installed by running in the REPL package manager (]):
add BcdiMesoSettings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
Bragg Coherent Diffraction Imaging (BCDI) Meso (Mesoscale) implements phase retrieval for mesoscale models with stochastic gradient descent.
While this package is marked as BCDI specific, the methods are more general and can be used in many phase retrieval problems. In the future, this package may be incorporated into a more general phase retrieval package.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
BcdiStrain.jl is registered in the Julia general registry and can be installed by running in the REPL package manager (]):
add BcdiMesoSettings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
BcdiMeso implements phase retrieval in operator-style format. This means that the multiplication (*) and power (^) operators are used to apply operators to some current state. This may look like the following:
state = State(intens, gVecs, recSupport, x, y, z, rho, ux, uy, uz)
+Usage · BcdiDocs Overview
BcdiMeso implements phase retrieval in operator-style format. This means that the multiplication (*) and power (^) operators are used to apply operators to some current state. This may look like the following:
state = State(intens, gVecs, recSupport, x, y, z, rho, ux, uy, uz)
optimizeState = OptimizeState(state, primitiveRecipLattice, numPeaks)
-optimizeState^100 * state
This short script applies 100 stochastic gradient descent iterations iterations. This makes it easy to implement very complex recipes for phase retrieval algorithms.
API
BcdiMeso.State — TypeCreate an object that performs an iteration of stochastic gradient descent.
Create the reconstruction state.
sourceBcdiMeso.OptimizeState — TypeOptimizeState(state, primitiveRecipLattice, numPeaks)
Create an object that performs an iteration of stochastic gradient descent.
sourceSettings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
This short script applies 100 stochastic gradient descent iterations iterations. This makes it easy to implement very complex recipes for phase retrieval algorithms.
BcdiMeso.State — TypeState(intensities, gVecs, recSupport, x, y, z, rho, ux, uy, uz)
Create the reconstruction state. intensities is a vector of fully measured diffraction peaks, gVecs is a vector of peak locations, and recSupport is a vector of masks over the intensities that removes those intenities from the reconstruction process. The positions of real space points (x, y, and z) must be passed in as well as the magnitude of the electron density rho and the displacement field (ux, uy, and uz).
The initialization process shifts each peak to be centered (i.e. the center of mass of the peak is moved to the center of the image).
BcdiMeso.OptimizeState — TypeOptimizeState(state, primitiveRecipLattice, numPeaks)Create an object that performs an iteration of stochastic gradient descent. numPeaks number of peaks are selected randomly. One step of gradient descent is taken using the More-Thuente linesearch.
This implimentation takes into account effects of small angle measurement usually ignored in the BCDI problem. This is described in [4] although this implimentation will be faster because a NUFFT is used instead of many FFTs.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
[deps]
+Examples · BcdiDocs Example 1
Environment
[deps]
BcdiCore = "72eb6a3e-ca63-4742-b260-85b05ca6d9e4"
BcdiStrain = "3abd092d-e7bc-4ec6-94c6-c6851986118d"
BcdiMeso = "1ffc817a-885e-4a73-a887-574cb954c7d7"
@@ -109,4 +109,4 @@
mov(a, "../results/recon.webm", fps=250)
end
-phase()
Output
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
<!– 
–>
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Bragg Coherent Diffraction Imaging (BCDI) Simulate implements methods to simulate the BCDI problem. Currently, BcdiSimulate only implements atomic scale methods, we may expand these capabilities.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
BcdiSimulate.jl is not registered in the Julia general registry and can be installed by running in the REPL package manager (]):
add https://github.com/byu-cxi/BcdiMeso.jl.gitSettings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
BcdiSimulate.atomSimulateElectricField — MethodatomSimulateElectricField(x, y, z, hRanges, kRanges, lRanges)Simulate the electric field for a group of atoms (x, y, and z) on a sequence of grids in reciprocal space (hRanges, kRanges, lRanges). More concretely, calculate
$F_{hkl} = e^{- 2 \pi i (x h + y k + z l)}}$
x, y, and z do not have to lie on any grid and are assumed to be Vector{Real}. 'hRanges', 'kRanges' and 'lRanges' are not individual points, but are Vector{StepRangeLen}, that together, define the grid to sample reciprocal space over. In general, this will be faster than a full discrete Fourier transform (with $O(n^2)$ operations) because it uses an NUFFT.
BcdiSimulate.atomSimulateDiffraction — MethodatomSimulateDiffraction(x, y, z, hRanges, kRanges, lRanges, numPhotons; seed=nothing)Simulate diffraction patterns for a group of atoms (x, y, and z) on a sequence of grids in reciprocal space (hRanges, kRanges, lRanges). More concretely, obtain samples from a Poisson distribution that satisfy
$I_hkl} \overset{ind}{\sim} Pois(F_{hkl})$
where
$F_{hkl} = e^{- 2 \pi i (x h + y k + z l)}}$
x, y, and z do not have to lie on any grid and are assumed to be Vector{Real}. 'hRanges', 'kRanges' and 'lRanges' are not individual points, but are Vector{StepRangeLen}, that together, define the grid to sample reciprocal space over. numPhotons defines the number of photons that will, on average, be simulated, and seed is the rng seed. In general, this will be faster than a full discrete Fourier transform (with $O(n^2)$ operations) because it uses an NUFFT.
BcdiSimulate.relaxCrystal — MethodrelaxCrystal(x, y, z, lmpOptions, potentialName)Use LAMMPS to relax the supplied atom positions (x, y, and z). lmpOptions defines command line options to pass to LAMMPS and the potentialName defines the interatomic potential used in the LAMMPS relaxation.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
<!– 
–>
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
<!– –>
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Bragg Coherent Diffraction Imaging (BCDI) Strain implements projection-based phase retrieval algorithms.
While this package is marked as BCDI specific, the methods are more general and can be used in many phase retrieval problems. In the future, this package may be incorporated into a more general phase retrieval package.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
Currently, BcdiStrain.jl is not registered in the Julia general registry and can be installed by running in the REPL package manager (]):
add BcdiStrainSettings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
Bragg Coherent Diffraction Imaging (BCDI) Strain implements projection-based phase retrieval algorithms.
While this package is marked as BCDI specific, the methods are more general and can be used in many phase retrieval problems. In the future, this package may be incorporated into a more general phase retrieval package.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
BcdiStrain.jl is registered in the Julia general registry and can be installed by running in the REPL package manager (]):
add BcdiStrainSettings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
BcdiStrain implements projection-based algorithms in operator-style format. This means that the multiplication (*) and power (^) operators are used to apply operators to some current state. This may look like the following:
er = BcdiTrad.ER()
+Usage · BcdiDocs Overview
BcdiStrain implements projection-based algorithms in operator-style format. This means that the multiplication (*) and power (^) operators are used to apply operators to some current state. This may look like the following:
er = BcdiTrad.ER()
hio = BcdiTrad.HIO(0.9)
state = BcdiTrad.State(intensities, trues(size(intensities)))
-(er * hio^20)^5 * state
This short script applies 20 HIO iterations and one ER iterations for a total of 5 times. This makes it easy to implement very complex recipes for phase retrieval algorithms.
API
BcdiStrain.State — TypeState(intensities, recSupport)
Create a reconstruction object. The intensities and a mask over reciprocal space indicating trusted intensities need to be passed in.
sourceBcdiStrain.ER — TypeER()
Create an object that applies an iteration of ER
sourceBcdiStrain.HIO — TypeHIO(beta)
Create an object that applies an iteration of HIO
sourceBcdiStrain.Shrink — TypeShrink(threshold, sigma, state)
Create an object that applies shrinkwrap
sourceBcdiStrain.Center — TypeCenter(state)
Create an object that centers the current state
sourceBcdiStrain.Mount — TypeMount(beta, state, primitiveRecipLattice)
Create an object that switches between peaks.
sourceSettings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
This short script applies 20 HIO iterations and one ER iterations for a total of 5 times. This makes it easy to implement very complex recipes for phase retrieval algorithms.
BcdiStrain.State — TypeState(intensities, gVecs, recSupport)
+State(intensities, gVecs, recSupport, support)Create a reconstruction object. intensities is a vector of fully measured diffraction peaks, gVecs is a vector of peak locations, and recSupport is a vector of masks over the intensities that removes those intenities from the reconstruction process.
The initialization process shifts each peak to be centered in the Fourier sense (i.e. the center of mass of the peak is moved to the edge of the image, or the zero frequency). If the support is not passed in, an initial guess of the support is created by taking an IFFT of the intensities and including everything above 0.1 times the maximum value.
BcdiStrain.ER — TypeER()Create an object that applies one iteration of Error Reduction (ER) to the currently Mounted peak. ER is an iterative projection algorithm that enforces two constraints, (1) the modulus constraint and (2) the support constraint:
One iteration of ER first applies the modulus constraint, then the support constraint to the object, then returnns.
Gradient descent is an alternate way to view the ER algorithm becausee ER is equivalent to gradient descent with a step size of 0.5.
More information about the ER algorithm can be found in [1, 2].
BcdiStrain.HIO — TypeHIO(beta)Create an object that applies an iteration of hybrid input-output (HIO) to the currently Mounted peak. On the interior of the support, HIO is equivalent to applying the modulus constraint as described in the ER algorithm, and on the exterior of the support, HIO is equal to the current reconstruction minus a fraction of the output after applying the modulus constraint, that is,
\[\rho_{i+1} = \begin{cases} +ER(\rho_i) & \rho \in support \\ +\rho_i - \beta * ER(\rho_i) & \rho \notin support +\end{cases}\]
Marchesini [2] has shown that the HIO algorithm is equivalent to a mini-max problem.
More information about the HIO algorithm can be found in [1, 2].
BcdiStrain.Shrink — TypeShrink(threshold, sigma, state::State)Create an object that applies one iteration of the shrinkwrap algorithm to the current real space object. Shrinkwrap first applies a Gaussian blur to the current reconstruction using sigma as the width of the Gaussian. The support is then created from everything above the threshold times maximum value of the blurred object.
Further information about the shrinkwrap algorithm can be found in [3].
BcdiStrain.Center — TypeCenter(state)Create an object that centers the current real space object. The center of mass of the support is calculated and the object is moved so the center of mass is centered in the Fourier transform sense. In other words, the center of mass is moved to the zeroth frequency, or the bottom left corner of the image.
BcdiStrain.Mount — TypeMount(beta, state, primitiveRecipLattice)Create an object that mounts a new peak. The current real space object is projected back to update the magnitude of the electron density and the displacement field. A new peak is selected at random and the current solution is projected out to this peak.
The paper that describes this algorithm is currently in submission.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
[deps]
+Examples · BcdiDocs Example 1
Environment
[deps]
BcdiStrain = "3abd092d-e7bc-4ec6-94c6-c6851986118d"
FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
Code
using BcdiStrain
@@ -62,4 +62,4 @@
mov(a, "../results/recon.webm", fps=250)
end
-phase()
Output
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
<!– 
–>
Bragg Coherent Diffraction Imaging (BCDI) Trad (Traditional) implements projection-based phase retrieval algorithms. Some of the core functionality of this project is implemented in BcdiCore.jl. Additionally, this package is part of a collection of BCDI packages consisting of BcdiAtomic.jl (an atomic scale BCDI solver), BcdiMeso.jl (a mesoscale BCDI Solver), and BcdiMulti.jl (a multiscale BCDI solver).
While this package is marked as BCDI specific, the methods are more general and can be used in many phase retrieval problems. In the future, this package may be incorporated into a more general phase retrieval core package.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
Currently, BcdiTrad.jl is registered in the Julia general registry and can be installed by running in the REPL package manager (]):
add BcdiTradSettings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
<!– –>
Bragg Coherent Diffraction Imaging (BCDI) Trad (Traditional) implements projection-based phase retrieval algorithms. Some of the core functionality of this project is implemented in BcdiCore.jl. Additionally, this package is part of a collection of BCDI packages consisting of BcdiAtomic.jl (an atomic scale BCDI solver), BcdiMeso.jl (a mesoscale BCDI Solver), and BcdiMulti.jl (a multiscale BCDI solver).
While this package is marked as BCDI specific, the methods are more general and can be used in many phase retrieval problems. In the future, this package may be incorporated into a more general phase retrieval core package.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
Currently, BcdiTrad.jl is registered in the Julia general registry and can be installed by running in the REPL package manager (]):
add BcdiTradSettings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Bragg Coherent Diffraction Imaging (BCDI) Trad (Traditional) implements projection-based phase retrieval algorithms.
While this package is marked as BCDI specific, the methods are more general and can be used in many phase retrieval problems. In the future, this package may be incorporated into a more general phase retrieval core package.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
BcdiTrad.jl is registered in the Julia general registry and can be installed by running in the REPL package manager (]):
add BcdiTradSettings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
Bragg Coherent Diffraction Imaging (BCDI) Trad (Traditional) implements projection-based phase retrieval algorithms.
While this package is marked as BCDI specific, the methods are more general and can be used in many phase retrieval problems. In the future, this package may be incorporated into a more general phase retrieval core package.
Currently, this entire package must be run with access to GPUs. This may change in the future (especially if Issues requesting it are opened), but for our research group, using GPUs is a necessity.
BcdiTrad.jl is registered in the Julia general registry and can be installed by running in the REPL package manager (]):
add BcdiTradSettings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Similar to pynx and others?, BcdiTrad implements projection-based algorithms in operator-style format. This means that the multiplication (*) and power (^) operators are used to apply operators to some current state. This may look like the following:
er = BcdiTrad.ER()
+Usage · BcdiDocs Overview
Similar to pynx and others?, BcdiTrad implements projection-based algorithms in operator-style format. This means that the multiplication (*) and power (^) operators are used to apply operators to some current state. This may look like the following:
er = BcdiTrad.ER()
hio = BcdiTrad.HIO(0.9)
state = BcdiTrad.State(intensities, trues(size(intensities)))
-(er * hio^20)^5 * state
This short script applies 20 HIO iterations and one ER iterations for a total of 5 times. This makes it easy to implement very complex recipes for phase retrieval algorithms.
API
BcdiTrad.State — TypeState(intensities, recSupport)
Create a reconstruction object. The intensities and a mask over reciprocal space indicating trusted intensities need to be passed in.
sourceBcdiTrad.ER — TypeER()
Create an object that applies an iteration of ER
sourceBcdiTrad.HIO — TypeHIO(beta)
Create an object that applies an iteration of HIO
sourceBcdiTrad.Shrink — TypeShrink(threshold, sigma, state)
Create an object that applies shrinkwrap
sourceBcdiTrad.Center — TypeCenter(state)
Create an object that centers the current state
sourceSettings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
This short script applies 20 HIO iterations and one ER iterations for a total of 5 times. This makes it easy to implement very complex recipes for phase retrieval algorithms.
BcdiTrad.State — TypeState(intensities, recSupport)
+State(intensities, recSupport, support)Create a reconstruction object. intensities is one fully measured diffraction peak and recSupport is a mask over the intensities that remove those intensities from the reconstruction process.
The initialization process shifts the peak to be centered in the Fourier sense (i.e. the center of mass of the peak is moved to the edge of the image, or the zero frequency). If the support is not passed in, an initial guess of the support is created by taking an IFFT of the intensities and including everything above 0.1 times the maximum value.
BcdiTrad.ER — TypeER()Create an object that applies one iteration of Error Reduction (ER). ER is an iterative projection algorithm that enforces two constraints, (1) the modulus constraint and (2) the support constraint:
One iteration of ER first applies the modulus constraint, then the support constraint to the object, then returnns.
Gradient descent is an alternate way to view the ER algorithm becausee ER is equivalent to gradient descent with a step size of 0.5.
More information about the ER algorithm can be found in [1, 2].
BcdiTrad.HIO — TypeHIO(beta)Create an object that applies an iteration of hybrid input-output (HIO). On the interior of the support, HIO is equivalent to applying the modulus constraint as described in the ER algorithm, and on the exterior of the support, HIO is equal to the current reconstruction minus a fraction of the output after applying the modulus constraint, that is,
\[\rho_{i+1} = \begin{cases} +ER(\rho_i) & \rho \in support \\ +\rho_i - \beta * ER(\rho_i) & \rho \notin support +\end{cases}\]
Marchesini [2] has shown that the HIO algorithm is equivalent to a mini-max problem.
More information about the HIO algorithm can be found in [1, 2].
BcdiTrad.Shrink — TypeShrink(threshold, sigma, state::State)Create an object that applies one iteration of the shrinkwrap algorithm. Shrinkwrap first applies a Gaussian blur to the current reconstruction using sigma as the width of the Gaussian. The support is then created from everything above the threshold times maximum value of the blurred object.
Further information about the shrinkwrap algorithm can be found in [3].
BcdiTrad.Center — TypeCenter(state)Create an object that centers the current state. The center of mass of the support is calculated and the object is moved so the center of mass is centered in the Fourier transform sense. In other words, the center of mass is moved to the zeroth frequency, or the bottom left corner of the image.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
[deps]
+Examples · BcdiDocs Example 1
Environment
[deps]
BcdiTrad = "b788224a-5de6-46e5-9aeb-ad1a5171efd9"
FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
Code
using BcdiTrad
@@ -39,4 +39,4 @@
mov(a, "../results/recon.webm", fps=250)
end
-phase()
Output
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
The BYU-CXI research group maintains a suite of Julia packages to solve the Bragg Coherent Diffraction Imaging (BCDI) problem in several different regimes and circumstance.
BcdiCore.jl implements all of the Fourier transforms for the Julia BCDI packages. In addition, BcdiCore calculates the loss function used (either $L_2$ or the MLE estimator) and derivatives of these loss functions.
BcdiTrad.jl implements projection-based BCDI algorithm. Currently, this is limited to ER, HIO, and shrinkwrap.
BcdiStrain.jl implements a multi-peak BCDI algorithm developed by the BYU-CXI group. In addition to the alogrithms present in BcdiTrad, BcdiStrain also implements Mount, an operator that switches between peaks.
BcdiMeso.jl implements a BCDI algorithm that solves in the mesoscale regime. Instead of using projections, this algorithm uses a gradient-based optimization scheme. Additionally, BcdiMeso does not assume a small measurement distance away from the peak.
BcdiAtomic.jl is an upcoming BCDI package that implements a BCDI algorithm that solves at the atomic scale.
BcdiMulti.jl is an upcoming BCDI package that implements a multiscale BCDI algorithm that solves at both the mesoscale and the atomic scale.
BcdiSimulate.jl is an upcoming BCDI package that simulates the BCDI problem. Currently, this is only implimented at the atomic scale.
Settings
This document was generated with Documenter.jl version 1.6.0 on Friday 23 August 2024. Using Julia version 1.10.4.
The BYU-CXI research group maintains a suite of Julia packages to solve the Bragg Coherent Diffraction Imaging (BCDI) problem in several different regimes and circumstance.
BcdiCore.jl (github repo) implements all of the Fourier transforms for the Julia BCDI packages. In addition, BcdiCore calculates the loss function used (either $L_2$ or the MLE estimator) and derivatives of these loss functions.
BcdiTrad.jl (github repo) implements projection-based BCDI algorithm. Currently, this is limited to ER, HIO, and shrinkwrap.
BcdiStrain.jl (github repo) implements a multi-peak BCDI algorithm developed by the BYU-CXI group. In addition to the alogrithms present in BcdiTrad, BcdiStrain also implements Mount, an operator that switches between peaks.
BcdiMeso.jl (github repo) implements a BCDI algorithm that solves in the mesoscale regime. Instead of using projections, this algorithm uses a gradient-based optimization scheme. Additionally, BcdiMeso does not assume a small measurement distance away from the peak.
BcdiAtomic.jl is an upcoming BCDI package that implements a BCDI algorithm that solves at the atomic scale.
BcdiMulti.jl is an upcoming BCDI package that implements a multiscale BCDI algorithm that solves at both the mesoscale and the atomic scale.
BcdiSimulate.jl (github repo) implements algorithms that simulate the BCDI problem. Currently, this is only implimented at the atomic scale.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.
Settings
This document was generated with Documenter.jl version 1.6.0 on Monday 26 August 2024. Using Julia version 1.10.4.