licenses
sequencelengths 1
3
| version
stringclasses 677
values | tree_hash
stringlengths 40
40
| path
stringclasses 1
value | type
stringclasses 2
values | size
stringlengths 2
8
| text
stringlengths 25
67.1M
| package_name
stringlengths 2
41
| repo
stringlengths 33
86
|
|---|---|---|---|---|---|---|---|---|
[
"MIT"
] | 0.5.11 | b92e9e2b356146918c4f3f3845571abcf0501594 | docs | 2510 | # IntervalRootFinding.jl
[](https://github.com/JuliaIntervals/IntervalRootFinding.jl/actions/workflows/CI.yml)
[](https://codecov.io/gh/JuliaIntervals/IntervalRootFinding.jl)
[](https://juliaintervals.github.io/pages/packages/intervalrootfinding/)
This package provides guaranteed methods for finding **roots** of functions, i.e. solutions to the equation `f(x) == 0` for a function `f`.
To do so, it uses methods from interval analysis, using interval arithmetic from the [`IntervalArithmetic.jl`](https://github.com/JuliaIntervals/IntervalArithmetic.jl) package by the same authors.
## Basic usage examples
The basic function is `roots`. A standard Julia function and an interval is provided and the `roots` function return a list of intervals containing *all* roots of the function located in the starting interval.
```jl
julia> using IntervalArithmetic, IntervalRootFinding
julia> f(x) = sin(x) - 0.1*x^2 + 1
f (generic function with 1 method)
julia> roots(f, -10..10)
4-element Array{Root{Interval{Float64}},1}:
Root([3.14959, 3.1496], :unique)
Root([-4.42654, -4.42653], :unique)
Root([-1.08205, -1.08204], :unique)
Root([-3.10682, -3.10681], :unique)
```
The `:unique` status tell us, in addition, that each listed region contains exactly one root. The other possible status is `:unknown`, which corresponds to intervals that may contain zero, one, or more roots - no guarantee is provided for these intervals.
These results are represented in the following plot, the region containing roots being in green. The inset show a close-up of one of the roots:
The full documentation is available [here](https://juliaintervals.github.io/IntervalRootFinding.jl/latest/).
## Authors
- [Luis Benet](http://www.cicc.unam.mx/~benet/), Instituto de Ciencias Físicas,
Universidad Nacional Autónoma de México (UNAM)
- [David P. Sanders](http://sistemas.fciencias.unam.mx/~dsanders),
Departamento de Física, Facultad de Ciencias, Universidad Nacional Autónoma de México (UNAM)
## Acknowledgements ##
Financial support is acknowledged from DGAPA-UNAM PAPIME grants PE-105911 and PE-107114, and DGAPA-UNAM PAPIIT grants IN-117214 and IN-117117. LB acknowledges support through a *Cátedra Moshinsky* (2013).
| IntervalRootFinding | https://github.com/JuliaIntervals/IntervalRootFinding.jl.git |
|
[
"MIT"
] | 0.5.11 | b92e9e2b356146918c4f3f3845571abcf0501594 | docs | 491 |
# Test suites:
- http://folk.uib.no/ssu029/Pdf_file/Testproblems/testprobRheinboldt03.pdf
- http://www.mat.univie.ac.at/~neum/glopt/test.html
- http://titan.princeton.edu/TestProblems/
- http://www-sop.inria.fr/saga/POL/
- MINPACK benchmarks: https://github.com/JuliaNLSolvers/NLsolve.jl/blob/master/test/minpack.jl
and other files in NLsolve test suite
# Papers
- Testing unconstrained optimization software, Moré, Garbow, Hillstrom ACM Trans. Math. Soft. 7 (1), 17-41 (1981)
| IntervalRootFinding | https://github.com/JuliaIntervals/IntervalRootFinding.jl.git |
|
[
"MIT"
] | 0.5.11 | b92e9e2b356146918c4f3f3845571abcf0501594 | docs | 558 | # API
## Main interface
```@autodocs
Modules = [IntervalRootFinding]
Pages = ["roots.jl"]
```
## `Root` object
```@autodocs
Modules = [IntervalRootFinding]
Pages = ["root_object.jl"]
```
## Contractors
```@autodocs
Modules = [IntervalRootFinding]
Pages = ["contractors.jl"]
```
## Branch-and-bound search interface
```@autodocs
Modules = [IntervalRootFinding]
Pages = ["branch_and_bound.jl"]
```
## Others
```@autodocs
Modules = [IntervalRootFinding]
Pages = ["complex.jl", "linear_eq.jl", "newton1d.jl", "quadratic.jl", "slopes.jl"]
```
| IntervalRootFinding | https://github.com/JuliaIntervals/IntervalRootFinding.jl.git |
|
[
"MIT"
] | 0.5.11 | b92e9e2b356146918c4f3f3845571abcf0501594 | docs | 438 | # Bibliography
- *Applied Interval Analysis*, L. Jaulin, M. Kieffer, O. Didrit & E. Walter. Springer (2001)
- *Global Optimization Using Interval Analysis: Revised And Expanded*, E. Hansen & G.W. Walster. CRC Press (2003)
- *Introduction to Interval Analysis*, R.E. Moore, R.B. Kearfott & M.J. Cloud. SIAM (2009)
- *Validated Numerics: A Short Introduction to Rigorous Computations*, W. Tucker. Princeton University Press (2010)
| IntervalRootFinding | https://github.com/JuliaIntervals/IntervalRootFinding.jl.git |
|
[
"MIT"
] | 0.5.11 | b92e9e2b356146918c4f3f3845571abcf0501594 | docs | 5314 | # `IntervalRootFinding.jl`
This package provides guaranteed methods for finding **roots** of functions $f: \mathbb{R}^n \to \mathbb{R}^n$ with $n \ge 1$, i.e. vectors (or scalars, for $n=1$) $\mathbb{x}$ for which $f(\mathbb{x}) = \mathbb{0}$. In principle, it guarantees to find *all* roots inside a given box in $\mathbb{R}^n$, or report subboxes for which it is unable to provide guarantees.
To do so, it uses methods from interval analysis, using interval arithmetic from the [`IntervalArithmetic.jl`](https://github.com/JuliaIntervals/IntervalArithmetic.jl) package by the same authors.
!!! warning
While this package aimed at providing *guaranteed results* and despite our best efforts and test suite, some bugs may remain and there are several known issues with corner cases. Please look at the [issue tracker](https://github.com/JuliaIntervals/IntervalRootFinding.jl/issues) and report there any odd and/or incorrect behavior.
## Basic 1D example
To begin, we need a standard Julia function and an interval in which to search roots of that function. Intervals use the `Interval` type provided by the `IntervalArithmetic.jl` package and are generally constructed using the `..` syntax, `a..b` representing the closed interval $[a, b]$.
When provided with this information, the `roots` function will return a vector of all roots of the function in the given interval.
Example:
```jl
julia> using IntervalArithmetic, IntervalRootFinding
julia> rts = roots(x -> x^2 - 2x, 0..10)
2-element Array{Root{Interval{Float64}},1}:
Root([1.99999, 2.00001], :unique)
Root([0, 4.4724e-16], :unknown)
```
The roots are returned as `Root` objects, containing an interval and the status of that interval, represented as a `Symbol`. There are two possible types of root status, as shown in the example:
- `:unique`: the given interval contains *exactly one* root of the function,
- `:unknown`: the given interval may or may not contain one or more roots; the algorithm used was unable to come to a conclusion.
The second status is still informative, since all regions of the original search interval *not* contained in *any* of the returned root intervals is guaranteed *not* to contain any root of the function. In the above example, we know that the function has no root in the interval $[2.1, 10]$, for example.
There are several known situations where the uniqueness (and existence) of a solution cannot be determined by the interval algorithms used in the package:
- If the solution is on the boundary of the interval (as in the previous example);
- If the derivative of the solution is zero at the solution.
In particular, the second condition means that multiple roots cannot be proven to be unique. For example:
```jl
julia> g(x) = (x^2 - 2)^2 * (x^2 - 3)
g (generic function with 1 method)
julia> roots(g, -10..10)
4-element Array{IntervalRootFinding.Root{IntervalArithmetic.Interval{Float64}},1}:
Root([1.73205, 1.73206], :unique)
Root([1.41418, 1.4148], :unknown)
Root([-1.4148, -1.41418], :unknown)
Root([-1.73206, -1.73205], :unique)
```
Here we see that the two double roots are reported as being possible roots without guarantee and the simple roots have been proved to be unique.
## Basic multi-dimensional example
For dimensions $n > 1$, the function passed to `roots` must currently return an `SVector` from the `StaticArrays.jl` package.
Here we give a 3D example:
```jl
julia> function g( (x1, x2, x3) )
return SVector(x1^2 + x2^2 + x3^2 - 1,
x1^2 + x3^2 - 0.25,
x1^2 + x2^2 - 4x3
)
end
g (generic function with 1 method)
julia> X = -5..5
[-5, 5]
julia> rts = roots(g, X × X × X)
4-element Array{Root{IntervalBox{3,Float64}},1}:
Root([0.440762, 0.440763] × [0.866025, 0.866026] × [0.236067, 0.236068], :unique)
Root([0.440762, 0.440763] × [-0.866026, -0.866025] × [0.236067, 0.236068], :unique)
Root([-0.440763, -0.440762] × [0.866025, 0.866026] × [0.236067, 0.236068], :unique)
Root([-0.440763, -0.440762] × [-0.866026, -0.866025] × [0.236067, 0.236068], :unique)
```
Thus the system admits four unique roots in the box $[-5, 5]^3$. We have used the unicode character `×` (typed as `\times<tab>`) to compose several intervals into a multidimensional box.
## Stationary points
Stationary points of a function $f:\mathbb{R}^n \to \mathbb{R}$ may be found as zeros of the gradient of $f$.
The package exports the `∇` operator to calculate gradients using `ForwardDiff.jl`:
```jl
julia> f( (x, y) ) = sin(x) * sin(y)
f (generic function with 1 method)
julia> ∇f = ∇(f) # gradient operator from the package
(::#53) (generic function with 1 method)
julia> rts = roots(∇f, IntervalBox(-5..6, 2), Newton, 1e-5)
25-element Array{IntervalRootFinding.Root{IntervalArithmetic.IntervalBox{2,Float64}},1}:
Root([4.71238, 4.71239] × [4.71238, 4.71239], :unique)
Root([4.71238, 4.71239] × [1.57079, 1.5708], :unique)
⋮
[output snipped for brevity]
```
Now let's find the midpoints and plot them:
```jl
midpoints = mid.(interval.(rts))
xs = first.(midpoints)
ys = last.(midpoints)
using Plots; plotlyjs()
surface(-5:0.1:6, -6:0.1:6, (x,y) -> f([x, y]))
scatter!(xs, ys, f.(midpoints))
```
The result is the following:
| IntervalRootFinding | https://github.com/JuliaIntervals/IntervalRootFinding.jl.git |
|
[
"MIT"
] | 0.5.11 | b92e9e2b356146918c4f3f3845571abcf0501594 | docs | 5614 | # Internals
This section describes some of the internal mechanism of the package and several ways to use them to customize a search.
## Branch and bound
When `roots` is called, it performs a **branch-and-bound** search, that is, it iteratively looks at a region $X$ and for each region tries to determine if it contains a root. It then does the following:
- If $X$ is proven to contain *no* root, it discards it.
- If $X$ is proven to contain *exactly one root*, it tries to get the best possible bounds for the root and store the resulting region in the list of `Root`s to output with a `:unique` status.
- If the test is inconclusive and the size of $X$ is smaller than the tolerance, it stores it in the list of `Root`s to output with `:unknown` status.
- If the test is inconclusive and the size of $X$ is larger than the tolerance, it bisects $X$ and then processes each resulting half.
At some point all regions will either have a determined status or be smaller than the tolerance, and the algorithm will halt and return all stored roots.
## Tree representation
A branch-and-bound search can be naturally represented as a binary tree: each leaf contains a region and its status and each node represents a bisection. If the tree is known, the topology of the whole search can be reconstructed. There is however a point not determined by the tree.
The branch and bound algorithm used by the `roots` function builds this tree and at the end collect all leaves containing a region with status either `:unknown` or `:unique`. We see below how to access the tree.
## Search strategy
While the tree representation is sufficient to know the topology of the search, it does not determine the order in which leaves are processed during the search. This has an influence on how the tree is created and the amount of memory used, but will not change the resulting tree, unless some limitations on the number of iterations or leaves are enforced.
!!! note
No such limitations are currently implemented, but they are planned. They will allow to deal, for example, with functions admitting an infinite amount of roots.
Two strategies are currently available: a breadth-first strategy (leaves closer to the root of the tree are processed first); and a depth-first strategy (leaves further away from the root are processed first).
## Contractors
To determine the status of a region, the algorithm uses so-called *contractors*. A `Contractor` is a callable object built from a function (in the case of `Bisection`) and possibly its derivative as well (for `Newton` and `Krawczyk`). When called with a region (wrapped in a `Root` object) and a tolerance, it returns the status of the root and the region (refined if the region contained a unique root).
```jl
julia> C = Newton(sin, cos)
Newton{typeof(sin),typeof(cos)}(sin, cos)
julia> C(Root(pi ± 0.001, :unknown), 1e-10)
Root([3.14159, 3.1416], :unique)
julia> C(Root(2 ± 0.001, :unkown), 1e-10)
Root([1.99899, 2.00101], :empty)
```
Contractors play a central role in the algorithm: they are the only part of it that varies for different methods.
## Search object
Now that we have presented the foundation of the internal algorithm, we can discuss the representation of the search. Each search strategy has a type associated, the defined types being `BreadthFirstSearch` and `DepthFirstSearch`.
A search must be given three pieces of information:
1. The region to search;
2. A contractor;
3. A tolerance.
```jl
julia> f(x) = exp(x) - sin(x)
f (generic function with 1 method)
julia> df(x) = exp(x) - cos(x)
df (generic function with 1 method)
julia> C = Newton(f, df)
Newton{typeof(f),typeof(df)}(f, df)
julia> search = DepthFirstSearch(-10..10, C, 1e-10)
DepthFirstSearch{Interval{Float64},Newton{typeof(f),typeof(df)},
Float64}(Root([-10, 10], :unknown), Newton{typeof(f),typeof(df)}(f, df),
1.0e-10)
```
Then the search is performed using the iterator interface, i.e. a `for` loop.
```jl
julia> current_tree = nothing # stores current version of tree
julia> for tree in search
global current_tree = tree
end
julia> current_tree
Working tree with 9 elements of type Root{Interval{Float64}}
Indices: [1, 2, 3, 4, 5, 7, 8, 9, 10]
Structure:
[1] Node with children [2]
[2] Node with children [3, 4]
[3] Node with children [8, 9]
[8] Node with children [10]
[10] Leaf (:final) with data Root([-9.42486, -9.42485], :unique)
[9] Leaf (:final) with data Root([-6.28132, -6.28131], :unique)
[4] Node with children [5]
[5] Node with children [7]
[7] Leaf (:final) with data Root([-3.18307, -3.18306], :unique)
```
The elements of the iteration are the trees (of type `BBTree`) that get constructed during the search. In the above example we simply get the final iteration of the tree and show it. The list of final roots can be retrieved using the `data` function:
```jl
julia> data(endtree)
3-element Array{Root{Interval{Float64}},1}:
Root([-3.18307, -3.18306], :unique)
Root([-6.28132, -6.28131], :unique)
Root([-9.42486, -9.42485], :unique)
```
We can use this interface to do some analysis at each iteration.
```jl
julia> for (k, tree) in enumerate(search)
println("The tree at iteration $k has $(IntervalRootFinding.nnodes(tree)) nodes")
end
The tree at iteration 1 has 3 nodes
The tree at iteration 2 has 5 nodes
The tree at iteration 3 has 4 nodes
⋮ # several lines omitted for brevity
The tree at iteration 17 has 10 nodes
The tree at iteration 18 has 9 nodes
The tree at iteration 19 has 9 nodes
```
| IntervalRootFinding | https://github.com/JuliaIntervals/IntervalRootFinding.jl.git |
|
[
"MIT"
] | 0.5.11 | b92e9e2b356146918c4f3f3845571abcf0501594 | docs | 5773 | # `roots` interface
## Methods
Three root-finding methods currently available through the `roots` interface are the following:
- `Newton` (default);
- `Krawczyk`;
- `Bisection`
Both the Newton and Krawczyk methods can determine if a root is unique in an interval, at the cost of requiring that the function is differentiable. The bisection method has no such requirement, but can never guarantee the existence or uniqueness of a root.
The method used is given as the third (optional) argument of the `roots` function:
```jl
julia> roots(log, -2..2, Newton)
1-element Array{Root{Interval{Float64}},1}:
Root([0.999996, 1.00001], :unique)
julia> roots(log, -2..2, Krawczyk)
1-element Array{Root{Interval{Float64}},1}:
Root([0.999984, 1.00002], :unique)
julia> roots(log, -2..2, Bisection)
1-element Array{Root{Interval{Float64}},1}:
Root([0.999454, 1.00039], :unknown)
```
Note that as shown in the example, the `log` function does not complain about being given an interval going outside of its domain. While this may be surprising, this is the expected behavior and no root will ever be found outside the domain of a function.
## Explicit derivatives
Newton and Krawczyk methods require the function to be differentiable, but the derivative is usually computed automatically using forward-mode automatic differentiation, provided by the `ForwardDiff.jl` package. It is however possible to provide the derivative explicitly for these methods as the second argument of the `roots` function:
```jl
julia> roots(log, x -> 1/x, -2..2, Newton)
1-element Array{Root{Interval{Float64}},1}:
Root([0.999996, 1.00001], :unique)
julia> roots(log, x -> 1/x, -2..2, Krawczyk)
1-element Array{Root{Interval{Float64}},1}:
Root([0.999984, 1.00002], :unique)
```
When providing the derivative explicitly, the computation is expected to be slightly faster, but the precision of the result is unlikely to be affected.
```jl
julia> using BenchmarkTools
julia> @btime roots(log, x -> 1/x, -2..2, Newton)
38.600 μs (371 allocations: 27.01 KiB)
1-element Array{Root{Interval{Float64}},1}:
Root([0.999996, 1.00001], :unique)
julia> @btime roots(log, -2..2, Newton)
51.799 μs (373 allocations: 27.20 KiB)
1-element Array{Root{Interval{Float64}},1}:
Root([0.999996, 1.00001], :unique)
```
This may be useful in some special cases where `ForwardDiff.jl` is unable to compute the derivative of a function. Examples are complex functions and functions whose interval extension must be manually defined (e.g. special functions like `zeta`).
In dimension greater than one, the function of interest must return a `SVector`, a type provided by the `StaticArrays` package, but otherwise works in the same way as in the 1D case.
```jl
julia> function f( (x, y) )
return SVector(sin(x), cos(y))
end
f (generic function with 1 method)
julia> roots(f, IntervalBox(-3..3, 2))
2-element Array{Root{IntervalBox{2,Float64}},1}:
Root([-1.13556e-19, 2.3664e-20] × [1.57079, 1.5708], :unique)
Root([-7.92188e-19, 3.20973e-19] × [-1.5708, -1.57079], :unique)
```
When providing the derivative for a multi-dimensional function, this must be given as a function returning the Jacobi matrix of the function as an `SMatrix`:
```jl
julia> function df( (x, y) )
return SMatrix{2, 2}(cos(x), 0, 0, -sin(y))
end
df (generic function with 1 method)
julia> roots(f, df, IntervalBox(-3..3, 2), Newton)
2-element Array{Root{IntervalBox{2,Float64}},1}:
Root([-2.35877e-07, 8.22858e-07] × [1.57079, 1.5708], :unique)
Root([-7.19393e-07, 1.55473e-06] × [-1.5708, -1.57079], :unique)
```
## Tolerance
An absolute tolerance for the search may be specified as the last argument of the `roots` function, the default being `1e-15`. Currently a method must first be provided in order to be able to choose the tolerance.
```jl
julia> g(x) = sin(exp(x))
g (generic function with 1 method)
julia> roots(g, 0..2, Newton)
2-element Array{Root{Interval{Float64}},1}:
Root([1.83787, 1.83788], :unique)
Root([1.14472, 1.14473], :unique)
julia> roots(g, 0..2, Newton, 1e-2)
2-element Array{Root{Interval{Float64}},1}:
Root([1.83745, 1.83974], :unique)
Root([1.14471, 1.14475], :unique)
```
A lower tolerance may greatly reduce the computation time, at the cost of an increased number of returned roots having `:unknown` status:
```jl
julia> h(x) = cos(x) * sin(1 / x)
h (generic function with 1 method)
julia> @btime roots(h, 0.05..1, Newton)
1.316 ms (9676 allocations: 202.21 KiB)
6-element Array{Root{Interval{Float64}},1}:
Root([0.106103, 0.106104], :unique)
Root([0.318309, 0.31831], :unique)
Root([0.0795774, 0.0795775], :unique)
Root([0.0636619, 0.063662], :unique)
Root([0.0530516, 0.0530517], :unique)
Root([0.159154, 0.159155], :unique)
julia> @btime roots(h, 0.05..1, Newton, 1e-2)
475.500 μs (4171 allocations: 94.00 KiB)
6-element Array{Root{Interval{Float64}},1}:
Root([0.317179, 0.319299], :unique)
Root([0.157209, 0.165989], :unknown)
Root([0.104739, 0.107542], :unknown)
Root([0.0515382, 0.0531049], :unique)
Root([0.0785458, 0.0797755], :unknown)
Root([0.0570253, 0.0641614], :unknown)
julia> @btime roots(h, 0.05..1, Newton, 1e-1)
151.101 μs (1382 allocations: 32.86 KiB)
3-element Array{Root{Interval{Float64}},1}:
Root([0.107541, 0.165989], :unknown)
Root([0.283803, 0.3555], :unknown)
Root([0.0499999, 0.107542], :unknown)
```
The last example shows a case where the tolerance was too large to be able to isolate the roots in distinct regions.
!!! warning
For a root `x` of some function, if the absolute tolerance is smaller than `eps(x)` i.e. if `tol + x == x`, `roots` may never be able to converge to the required tolerance and the function may get stuck in an infinite loop.
| IntervalRootFinding | https://github.com/JuliaIntervals/IntervalRootFinding.jl.git |
|
[
"Apache-2.0"
] | 0.1.6 | 1870304e91f3157246a4d6e7c34821b69bb83583 | code | 628 | module GigaScatter
import Images, FileIO, ImageMagick, Colors, Distributions
const Raster = Array{Float64,3}
const RasterMix = Tuple{Array{Float64,3},Matrix{Float64},Matrix{Float64}}
include("colors.jl")
include("rasterize.jl")
include("combine.jl")
include("kernel.jl")
include("export.jl")
# colors.jl
export clusterPalette,
expressionPalette, classColors, expressionColors, scaleMinMax, scaleNorm
# rasterize.jl
export rasterize
# kernel.jl
export rasterKernelCircle, rasterKernelGauss
# combine.jl
export mixableRaster, mixRasters, mixedRaster
# export.jl
export solidBackground, savePNG, saveJPEG
end # module
| GigaScatter | https://github.com/LCSB-BioCore/GigaScatter.jl.git |
|
[
"Apache-2.0"
] | 0.1.6 | 1870304e91f3157246a4d6e7c34821b69bb83583 | code | 4054 |
"""
clusterPalette(n; alpha=1.0, h=0.0, hl=360.0, s::Array{Float64,1}=[0.7, 1.0], v=[1.0, 0.7])
Create an array of categorical colors suitable for plotting colored clusters.
# Arguments
- `n` number of colors
- `alpha` transparency
- `h`, `hs` starting hue and hue range
- `s`,`v` arrays of saturations and color values in the palette
(the numbers will be used in a cyclic manner)
"""
function clusterPalette(n; alpha = 1.0, h = 0.0, hl = 360.0, s = [0.7, 1.0], v = [1.0, 0.7])
[
Colors.convert(
Colors.RGBA,
Colors.HSVA(h + hl * (i - 1) / n, s[1+i%length(s)], v[1+i%length(v)], alpha),
) for i = 1:n
]
end
"""
linearPaletteBlend(c, r)
Internal function for picking the color blends from palette arrays
"""
function linearPaletteBlend(c, r)
k = size(c, 1)
kr = (k - 1) * r
i = Int64(trunc(kr))
if i < 0
return c[1, :]
end
if i >= (k - 1)
return c[k, :]
end
a = kr - i
return (1 - a) * c[i+1, :] + a * c[i+2, :]
end
# data taken from a modified RbYlBu from EmbedSOM, which was originally taken
# from ColorBrewer and slightly modified
palRdYlBu = Matrix{Float64}(
[
33 38 149
53 101 180
100 157 209
145 195 226
184 217 200
255 255 168
254 224 144
253 174 97
244 109 67
215 48 39
165 0 38
],
)
"""
expressionPalette(n; alpha=1.0, palette=palRdYlBu)
Create a palette of `n` colors with alpha `alpha` that is useful for displaying
expressions; by default a variation of the widely used RdYlBu palette is used.
Any supplied `palette` with colors ranging from 0 to `maxValue` can be expanded.
"""
function expressionPalette(
n::Int64;
alpha::Float64 = 1.0,
palette::Matrix{Float64} = palRdYlBu,
maxValue::Float64 = 255.0,
)
[
Colors.RGBA(x[1], x[2], x[3], alpha) for
x in [linearPaletteBlend(palette, (i - 1) / (n - 1)) for i = 1:n] / maxValue
]
end
"""
classColors(classes::Array{Int64, 1}, palette)::Matrix{Float64}
Take integer class IDs from `classes` and the corresponding colors in
`Palette`, and produce a corresponding color matrix usable in `rasterize`.
Optionally, `classCount` specifies the number of classes; by default taken as a
maximum of `classes` if `classCount` zero.
"""
function classColors(classes::Array{Int64,1}, palette)::Matrix{Float64}
hcat([[palette[i].r, palette[i].g, palette[i].b, palette[i].alpha] for i in classes]...)
end
"""
expressionColors(expressions::Array{Float64, 1}, palette)::Matrix{Float64}
Convert array of floating point `expressions` in range [0..1] to an array of
colors usable in `rasterize`, using the `palette` as a color lookup.
"""
function expressionColors(expressions::Array{Float64,1}, palette)::Matrix{Float64}
nColors = length(palette)
hcat(
[
[palette[c].r, palette[c].g, palette[c].b, palette[c].alpha] for
c in Array{Int64,1}(1 .+ trunc.((nColors - 1) * expressions))
]...,
)
end
"""
scaleMinMax(expressions::Array{Float64, 1})::Array{Float64, 1}
Linearly scale `expressions` into the interval [0..1], usable in
`expressionColors`.
"""
function scaleMinMax(expressions::Array{Float64,1})::Array{Float64,1} #TODO quantiles?
expressions .-= minimum(expressions)
m = maximum(expressions)
if m > 0
expressions ./= m
end
expressions
end
"""
scaleNorm(expressions::Array{Float64, 1})::Array{Float64, 1}
Scale `expressions` to quantile in their empirical normal distribution, i.e. to [0..1], usable in
`expressionColors`.
"""
function scaleNorm(expressions::Array{Float64,1})::Array{Float64,1}
len = length(expressions)
if len == 0
return []
end
# compute the empirical distribution
mu = sum(expressions) / len
var = sum((expressions .- mu) .^ 2) / len
if var == 0
var = 1 #save the day
end
dist = Distributions.Normal(mu, sqrt(var))
Distributions.cdf.(dist, expressions)
end
| GigaScatter | https://github.com/LCSB-BioCore/GigaScatter.jl.git |
|
[
"Apache-2.0"
] | 0.1.6 | 1870304e91f3157246a4d6e7c34821b69bb83583 | code | 1076 | """
mixableRaster(raster::Raster)::RasterMix
Convert a raster into a form that is suitable for combining with other rasters.
"""
function mixableRaster(raster::Raster)::RasterMix
colors = copy(raster[1:3, :, :])
colors[1, :, :] .*= raster[4, :, :]
colors[2, :, :] .*= raster[4, :, :]
colors[3, :, :] .*= raster[4, :, :]
return (colors, 1 .- raster[4, :, :], raster[4, :, :])
end
"""
mixRasters(
(c1,ia1,w1)::RasterMix,
(c2,ia2,w2)::RasterMix)::RasterMix
Combine 2 rasters into mixable form.
"""
function mixRasters((c1, ia1, w1)::RasterMix, (c2, ia2, w2)::RasterMix)::RasterMix
return (c1 .+ c2, ia1 .* ia2, w1 .+ w2)
end
"""
mixedRaster((r,ia,w)::RasterMix)::Raster
Convert several (possibly many) mixed rasters back into normal raster.
"""
function mixedRaster((r, ia, ws)::RasterMix)::Raster
w = copy(reshape(ws, (1, size(ws)...)))
w[w.==0] .= 1
cat(
dims = 1,
r[1:1, :, :] ./ w,
r[2:2, :, :] ./ w,
r[3:3, :, :] ./ w,
1 .- reshape(ia, (1, size(ia)...)),
)
end
| GigaScatter | https://github.com/LCSB-BioCore/GigaScatter.jl.git |
|
[
"Apache-2.0"
] | 0.1.6 | 1870304e91f3157246a4d6e7c34821b69bb83583 | code | 1755 | """
solidBackground(
raster::Array{Float64,3},
color::Array{Float64,1}=[1.0,1.0,1.0]
)::Array{Float64,3}
Take a 4-channel `raster` with alpha channel and convert it to 3-channel one by
adding a background `color`. Useful for saving non-transparent PNGs and JPEGs.
"""
function solidBackground(raster::Raster, color::Array{Float64,1} = [1.0, 1.0, 1.0])::Raster
r = copy(raster)
r[1, :, :] = r[1, :, :] .* r[4, :, :] + color[1] .* (1 .- r[4, :, :])
r[2, :, :] = r[2, :, :] .* r[4, :, :] + color[2] .* (1 .- r[4, :, :])
r[3, :, :] = r[3, :, :] .* r[4, :, :] + color[3] .* (1 .- r[4, :, :])
r[1:3, :, :]
end
"""
savePNG(filename::String, raster::Array{Float64,3})
Save the `raster` to a PNG `filename`. Transparency is choosen automatically
based on the number of raster channels.
"""
function savePNG(filename::String, raster::Raster)
format = Images.RGBA
if size(raster, 1) == 3
format = Images.RGB
elseif size(raster, 1) == 4
format = Images.RGBA
else
throw(DomainError(size(raster, 1), "unsupported number of channels in raster"))
end
Images.save(FileIO.File(FileIO.format"PNG", filename), Images.colorview(format, raster))
end
"""
saveJPEG(filename::String, raster::Array{Float64,3})
Save the `raster` to a JPEG `filename`. Only supports 3-channel rasters (see `solidBackground`).
"""
function saveJPEG(filename::String, raster::Raster)
format = Images.RGB
if size(raster, 1) == 3
format = Images.RGB
else
throw(DomainError(size(raster, 1), "unsupported number of channels in raster"))
end
Images.save(
FileIO.File(FileIO.format"JPEG", filename),
Images.colorview(format, raster),
)
end
| GigaScatter | https://github.com/LCSB-BioCore/GigaScatter.jl.git |
|
[
"Apache-2.0"
] | 0.1.6 | 1870304e91f3157246a4d6e7c34821b69bb83583 | code | 3672 | """
rasterKernelCircle(radius, raf::Array{Float64, 3})::Array{Float64, 3}
Expand single-pixel points in a raster (as obtained e.g. from `rasterize`) to
small circles with the specified `radius`. Alpha and color is preserved.
"""
function rasterKernelCircle(radius, raf::Raster)::Raster
# premultiply the radius
rt = radius * radius
# maximum required kernel offset
r = Int64(ceil(radius))
# resulting raster
res = zeros(Float64, size(raf))
for x = 1:size(raf, 2)
for y = 1:size(raf, 3)
sr = 0.0
sg = 0.0
sb = 0.0
pia = 1.0 # alpha is blended by multiplying (1-alpha) values
w = 0.0 # total weight
# run through the environment of x,y by offsets
for ox = (-r):r
for oy = (-r):r
# check if the offset is in limits
tx = x + ox
ty = y + oy
if tx < 1 || tx > size(raf, 2) || ty < 1 || ty > size(raf, 3)
continue
end
# cut out the circle (TODO: antialias the border??)
if ox * ox + oy * oy > rt
continue
end
# blend it
sr += raf[1, tx, ty] * raf[4, tx, ty]
sg += raf[2, tx, ty] * raf[4, tx, ty]
sb += raf[3, tx, ty] * raf[4, tx, ty]
w += raf[4, tx, ty]
pia *= 1 - raf[4, tx, ty]
end
end
# compute the weighted mean & convert the alpha back
if w > 0
res[1, x, y] = sr / w
res[2, x, y] = sg / w
res[3, x, y] = sb / w
res[4, x, y] = 1 - pia
end
end
end
res
end
"""
rasterKernelGauss(sigma, raf::Raster; approximation_limit=3.5)::Raster
Similar to [`rasterKernelCircle`](@ref), but expands smooth gaussian
neighborhoods rather than circle-ish ones. `approximation_limit` sets the size
of the kernel square in multiplies of `sigma`.
"""
function rasterKernelGauss(sigma, raf::Raster; approximation_limit = 3.5)::Raster
# premultiplied sigma
st = -1.0 / (sigma * sigma)
# limit
r = Int64(ceil(approximation_limit * sigma))
#result
res = zeros(Float64, size(raf))
for x = 1:size(raf, 2)
for y = 1:size(raf, 3)
sr = 0.0
sg = 0.0
sb = 0.0
pia = 1.0 # alpha is blended by multiplying (1-alpha) values
w = 0.0 # total weight
# run through the environment of x,y by offsets
for ox = (-r):r
for oy = (-r):r
# check if the offset is in limits
tx = x + ox
ty = y + oy
if tx < 1 || tx > size(raf, 2) || ty < 1 || ty > size(raf, 3)
continue
end
# gaussian alpha
ga = raf[4, tx, ty] * exp(st * (ox * ox + oy * oy))
# blend it
sr += raf[1, tx, ty] * ga
sg += raf[2, tx, ty] * ga
sb += raf[3, tx, ty] * ga
w += ga
pia *= 1 - ga
end
end
# compute the weighted mean & convert the alpha back
if w > 0
res[1, x, y] = sr / w
res[2, x, y] = sg / w
res[3, x, y] = sb / w
res[4, x, y] = 1 - pia
end
end
end
res
end
| GigaScatter | https://github.com/LCSB-BioCore/GigaScatter.jl.git |
|
[
"Apache-2.0"
] | 0.1.6 | 1870304e91f3157246a4d6e7c34821b69bb83583 | code | 3714 | """
rasterize(
res::Tuple{Int64, Int64},
points::Matrix{Float64},
colors::Matrix{Float64};
xlim = (minimum(points[:,1]), maximum(points[:,1])),
ylim = (minimum(points[:,2]), maximum(points[:,2]))
)::Array{Float64, 3}
Rasterize the `points` represented as coordinates in 2-row matrix colored by
RGBA float colors in the corresponding 4-row matrix into a raster of size
`res`. `xlim` and `ylim` are the point-coordinates of raster edges.
The raster is returned as a 3D RGBA array with coordinates as in
`[colorChannel, x, y]`.
"""
function rasterize(
res::Tuple{Int64,Int64},
points::Matrix{Float64},
colors::Matrix{Float64};
xlim = (minimum(points[1, :]), maximum(points[1, :])),
ylim = (minimum(points[2, :]), maximum(points[2, :])),
)::Raster
# Color blending is computed on integers because floats are just slower.
# `precision` is where the value of float 1.0 is mapped.
# Note that because there's multiplication in the process, the value of
# precision should not exceed the square root of maximum integer precision,
# in this case around 2^31. 100k as used here is MORE THAN ENOUGH for any
# thinkable use in this universe.
precision = Int64(100000)
# Most notably, having precision > 256 dodges the ugly low-alpha color
# artifacts that are pretty common with many graphics libraries.
# integer raster
ra = zeros(Int64, 4, res[1], res[2])
# minima
mins = [xlim[1], ylim[1]]
# actual raster point sizes
iszs = [res[1] / (xlim[2] - xlim[1]), res[2] / (ylim[2] - ylim[1])]
if size(points,1) != 2 || size(colors) != (4, size(points,2))
throw(ArgumentError("wrong input matrix sizes"))
end
@inbounds for i = 1:size(points, 2)
# convert the input coordinates to raster indexes
posx = trunc(Int64, (points[1, i] - mins[1]) * iszs[1]) + 1
posy = trunc(Int64, (points[2, i] - mins[2]) * iszs[2]) + 1
# skip if it's off limits
if posx < 1 || posx > res[1] || posy < 1 || posy > res[2]
continue
end
# get the src color
srcr = trunc(Int64, precision * colors[1, i])
srcg = trunc(Int64, precision * colors[2, i])
srcb = trunc(Int64, precision * colors[3, i])
srca = trunc(Int64, precision * colors[4, i])
# premultiply alpha
srcr = (srcr * srca) ÷ precision
srcg = (srcg * srca) ÷ precision
srcb = (srcb * srca) ÷ precision
# get the dst color
dstr = ra[1, posx, posy]
dstg = ra[2, posx, posy]
dstb = ra[3, posx, posy]
dsta = ra[4, posx, posy]
# aaaand it blends!
ra[1, posx, posy] = srcr + dstr - ((srca * dstr) ÷ precision)
ra[2, posx, posy] = srcg + dstg - ((srca * dstg) ÷ precision)
ra[3, posx, posy] = srcb + dstb - ((srca * dstb) ÷ precision)
ra[4, posx, posy] = srca + dsta - ((srca * dsta) ÷ precision)
end
#unmultiply alpha and convert back to floats in range 0..1
raf = zeros(Float64, 4, res[1], res[2])
for i = 1:res[1]
for j = 1:res[2]
# get the alpha element
raa = ra[4, i, j]
if raa == 0 #transparent black
continue
end
# remove alpha (which is still in precision-scale, so this
# effectively removes precision multiplication from r,g,b channels
raf[1, i, j] = ra[1, i, j] / raa
raf[2, i, j] = ra[2, i, j] / raa
raf[3, i, j] = ra[3, i, j] / raa
# and scale alpha back down to 0..1
raf[4, i, j] = ra[4, i, j] / precision
end
end
raf
end
| GigaScatter | https://github.com/LCSB-BioCore/GigaScatter.jl.git |
|
[
"Apache-2.0"
] | 0.1.6 | 1870304e91f3157246a4d6e7c34821b69bb83583 | docs | 3771 |
# GigaScatter.jl
Fast rasterization of huge amounts of tiny transparent points.
## How-To
First, get some data -- you will need point coordinates and their colors (in RGBA).
```julia
points = randn(2,100000)
colors = rand(4,100000)
```
After that, create a raster (of size 500x500):
```julia
using GigaScatter
raster = rasterize((500,500), points, colors)
```
The raster is now basically a 4-layer matrix with channels; you can write it to PNG and see what it looks like:
```julia
savePNG("demo-random.png", raster)
```
## Supporting functions
### Point size
For efficiency, points are not plotted as large immediately during rasterization, but you can later expand them by a kernel function (the results are same, but the kernel method is more efficient if you have more individual points than pixels in the resulting image, which is in fact common).
This expands the pixels to circles of radius `3.5`:
```julia
rasterWithBigPoints = rasterKernelCircle(3.5, raster)
```
### Colors
There are helper functions for coloring the points based on the class/category, and based on a real value (e.g. expression of some marker).
To plot categorical colors, you will need an integer array of categories (we create one manually from the data here):
```julia
points = vcat(randn(1000000)', rand(1000000)')
colors = classColors(
# numerically scale and truncate the floats to 10 categories
Array{Int64,1}(trunc.(points[2,:]*9) .+ 1),
# create a rainbow-like palette which is pretty good for categories
clusterPalette(10, alpha=.2))
raster = rasterize((500,500), points, colors)
savePNG("demo-classes.png", raster)
```
The same can be done with continuous properties of points, available as floating-point data:
```julia
# make some arbitrary floating point numbers from the data
vals = points[1,:] .* points[2,:]
colors = expressionColors(
# scale the data into interval 0..1, required by expressionColors
scaleNorm(vals), # (the other choice is scaleMinMax)
# create a RdYlBu-like palette with enough levels for continuous data
expressionPalette(256, alpha=.1))
raster = rasterize((500,500), points, colors)
savePNG("demo-values.png", raster)
```
### Transparency and background
By default, the raster is transparent. You can add an optionally colored background:
```julia
rasterOnWhite = solidBackground(raster)
rasterOnLightGray = solidBackground(raster, [0.5, 0.5, 0.5])
```
After the alpha channel is removed, saved PNGs will be slightly smaller, and you will be also able to export JPEG images (that cannot handle the alpha channel):
```julia
saveJPEG("demo-no-alpha.jpg", rasterOnLightGray)
```
### Usage with GigaSOM.jl
We assume you have the input DataFrame in `data` and cell-to-cluster mapping in `cl` with totally 10 categories:
```julia
# prepare the embedding first
som = GigaSOM.initGigaSOM(data, ...)
som = GigaSOM.trainGigaSOM(som, data, ...)
e = GigaSOM.embedGigaSOM(som, data, ...)
using GigaScatter
# plot the clusters
raster = rasterize((1024, 1024),
Matrix{Float64}(e'),
classColors(cl, clusterPalette(10, alpha=.2)))
savePNG("gigasom-clusters.png", rasterKernelCircle(2.5, raster))
# plot the expression from 5th column from the data
raster = rasterize((1024, 1024),
Matrix{Float64}(e'),
expressionColors(
scaleNorm(Array{Float64}(data[:,5])),
expressionPalette(100, alpha=.2)))
savePNG("gigasom-expression.png", rasterKernelCircle(2.5, raster))
```
| GigaScatter | https://github.com/LCSB-BioCore/GigaScatter.jl.git |
|
[
"MIT"
] | 0.2.0 | d1748496d967022306613c7a90be7509e4047836 | code | 530 | module TemperateOptimalPowerFlowGurobiExt
using TemperateOptimalPowerFlow
using Gurobi
import MathOptInterface as MOI
function __init__()
global gurobi_env = Gurobi.Env()
end
function TemperateOptimalPowerFlow.get_optimizer()
MOI.instantiate(() -> Gurobi.Optimizer(gurobi_env))
end
function TemperateOptimalPowerFlow.get_silent_optimizer()
MOI.instantiate(MOI.OptimizerWithAttributes(() -> Gurobi.Optimizer(gurobi_env), "OutputFlag" => 0))
end
end # module TemperateOptimalPowerFlowGurobiExt
| TemperateOptimalPowerFlow | https://github.com/gillioz/TemperateOptimalPowerFlow.jl.git |
|
[
"MIT"
] | 0.2.0 | d1748496d967022306613c7a90be7509e4047836 | code | 422 | module TemperateOptimalPowerFlowIpoptExt
using TemperateOptimalPowerFlow
using Ipopt
import MathOptInterface as MOI
function TemperateOptimalPowerFlow.get_optimizer()
MOI.instantiate(Ipopt.Optimizer)
end
function TemperateOptimalPowerFlow.get_silent_optimizer()
MOI.instantiate(MOI.OptimizerWithAttributes(Ipopt.Optimizer, "print_level" => 0))
end
end # module TemperateOptimalPowerFlowIpoptExt | TemperateOptimalPowerFlow | https://github.com/gillioz/TemperateOptimalPowerFlow.jl.git |
|
[
"MIT"
] | 0.2.0 | d1748496d967022306613c7a90be7509e4047836 | code | 436 | module TemperateOptimalPowerFlow
using MiniLoggers
using JSON
using SparseArrays
using LinearAlgebra
using DataDrop
using OrderedCollections
import MathOptInterface as MOI
include("setup.jl")
include("opf.jl")
include("analysis.jl")
include("extensions.jl")
function __init__()
MiniLogger(format="[{timestamp:blue}] {group:red:bold} {message}") |> global_logger
end
end # module TemperateOptimalPowerFlow | TemperateOptimalPowerFlow | https://github.com/gillioz/TemperateOptimalPowerFlow.jl.git |
|
[
"MIT"
] | 0.2.0 | d1748496d967022306613c7a90be7509e4047836 | code | 3409 |
export retrieve_gen_results, retrieve_injections, retrieve_loads
export retrieve_line_flows, retrieve_line_rates, retrieve_line_angles
export update_network!
function retrieve_gen_results(data_directory::String, result_file::String = "P_result";
include_nondispatch::Bool = true, zero_small_values::Bool = true, epsilon::Real = 1e-3)
P_gen = DataDrop.retrieve_matrix("$(data_directory)/$(result_file).h5")
if zero_small_values
P_gen[P_gen .< epsilon] .= 0.0
end
if !include_nondispatch || !isfile("$(data_directory)/P_nondispatch.h5")
return P_gen
end
P_nondispatch = DataDrop.retrieve_matrix("$(data_directory)/P_nondispatch.h5")
P_all = vcat(P_gen, P_nondispatch)
# compute the permutation matrix that re-orders the generators
gen_ids = DataDrop.retrieve_matrix("$(data_directory)/gen_ids.h5")
sorted_gen_ids = sort_strings(gen_ids)
n = length(gen_ids)
A = sparse([findfirst(==(id), sorted_gen_ids) for id in gen_ids], 1:n, ones(n), n, n)
return A * P_all
end
function retrieve_injections(data_directory::String, result_file::String = "P_result")
P_gen = DataDrop.retrieve_matrix("$(data_directory)/$(result_file).h5")
A_gen = DataDrop.retrieve_matrix("$(data_directory)/A_gen.h5")
A_load = DataDrop.retrieve_matrix("$(data_directory)/A_load.h5")
P_load = DataDrop.retrieve_matrix("$(data_directory)/P_load.h5")
if !isfile("$(data_directory)/P_nondispatch.h5")
return A_gen * P_gen - A_load * P_load
end
A_nondispatch = DataDrop.retrieve_matrix("$(data_directory)/A_nondispatch.h5")
P_nondispatch = DataDrop.retrieve_matrix("$(data_directory)/P_nondispatch.h5")
return A_gen * P_gen + A_nondispatch * P_nondispatch - A_load * P_load
end
function retrieve_line_flows(data_directory::String, result_file::String = "P_result")
P = retrieve_injections(data_directory, result_file)
L = DataDrop.retrieve_matrix("$(data_directory)/PTDF_matrix.h5")
return L * P
end
function retrieve_line_rates(data_directory::String, result_file::String = "P_result")
flows = retrieve_line_flows(data_directory, result_file)
thermal_limits = DataDrop.retrieve_matrix("$(data_directory)/thermal_limits.h5")
return abs.(flows) ./ thermal_limits
end
function retrieve_line_angles(data_directory::String, result_file::String = "P_result")
flows = retrieve_line_flows(data_directory, result_file)
susceptance = DataDrop.retrieve_matrix("$(data_directory)/susceptance.h5")
return abs.(flows) ./ susceptance
end
function retrieve_loads(data_directory::String)
return DataDrop.retrieve_matrix("$(data_directory)/P_load.h5")
end
function update_network!(network::Dict{String, Any}, loads::AbstractVector{<:Real},
gens::AbstractVector{<:Real}, lines::AbstractVector{<:Real})
# update loads
for (i, id) = enumerate(get_ordered_ids(network, "load"))
network["load"][id]["pd"] = loads[i]
network["load"][id]["qd"] = 0
end
# update gens
for (i, id) = enumerate(get_ordered_ids(network, "gen"))
network["gen"][id]["pg"] = gens[i]
network["gen"][id]["qg"] = 0
end
# update lines
for (i, id) = enumerate(get_ordered_ids(network, "branch"))
line = network["branch"][id]
line["pt"] = lines[i]
line["pf"] = -lines[i]
line["qt"] = 0
line["qf"] = 0
end
end | TemperateOptimalPowerFlow | https://github.com/gillioz/TemperateOptimalPowerFlow.jl.git |
|
[
"MIT"
] | 0.2.0 | d1748496d967022306613c7a90be7509e4047836 | code | 107 | export get_optimizer, get_silent_optimizer
function get_optimizer end
function get_silent_optimizer end
| TemperateOptimalPowerFlow | https://github.com/gillioz/TemperateOptimalPowerFlow.jl.git |
|
[
"MIT"
] | 0.2.0 | d1748496d967022306613c7a90be7509e4047836 | code | 12692 | export opf, partitioned_opf, compute
function opf(quadratic_cost::AbstractArray{<:Real,2}, linear_cost::AbstractArray{<:Real,2},
P_max::AbstractVector{<:Real}, P_exp::AbstractVector{<:Real},
P_total::AbstractVector{<:Real}; P_min::AbstractVector{<:Real} = Real[],
A_ramp::AbstractArray{<:Real,2} = Array{Real}(undef, 0, 0),
ΔP_ramp::AbstractVector{<:Real} = Real[],
P_ramp_first::AbstractVector{<:Real} = Real[], P_ramp_last::AbstractVector{<:Real} = Real[],
log_group::String = "", retry::Bool = true, debug::Bool = true, silent::Bool = true)
N = length(P_max)
T = length(P_total)
n_ramp = length(ΔP_ramp)
if length(P_min) == 0
P_min = zeros(N)
end
# check dimensions of the input
@assert length(P_exp) == N
@assert length(P_min) == N
@assert size(quadratic_cost) == (N, N)
@assert size(linear_cost) == (N, T)
@assert (size(A_ramp) == (n_ramp, N)) || (n_ramp == 0)
@assert length(P_ramp_first) ∈ [0, n_ramp]
@assert length(P_ramp_last) == length(P_ramp_first)
if n_ramp == 0
@info "OPF with $T time steps and $N generators" _group = log_group
else
ramp_constraint_type = length(P_ramp_first) == 0 ? "cyclic" : "fixed boundaries"
@info ("OPF with $T time steps, $N generators, " *
"and $n_ramp ramp constraints ($ramp_constraint_type)") _group = log_group
end
log_group = " "^length(log_group)
# check feasibility of the model
@info " -> checking model" _group = log_group
@assert all(P_exp .<= P_max)
@assert all(ΔP_ramp .>= 0)
@assert all(P_total .<= sum(P_max))
@assert abs(sum(P_total) / sum(P_exp) / T - 1) < 1e-2
optimizer = silent ? get_silent_optimizer() : get_optimizer()
@info " -> defining optimisation problem" _group = log_group
# variables
P_vec = MOI.add_variables(optimizer, N * T)
P = reshape(P_vec, (N, T))
# constraints
MOI.add_constraints(optimizer, P_vec, [MOI.Interval(P_min[i], P_max[i])
for t = 1:T for i = 1:N])
MOI.add_constraints(optimizer,
[MOI.ScalarAffineFunction([MOI.ScalarAffineTerm(1.0, P[i,t]) for t = 1:T], 0.0)
for i = 2:N],
[MOI.EqualTo(T * P_exp[i]) for i = 2:N])
MOI.add_constraints(optimizer,
[MOI.ScalarAffineFunction([MOI.ScalarAffineTerm(1.0, P[i,t]) for i = 1:N], 0.0)
for t = 1:T],
[MOI.EqualTo(P_total[t]) for t = 1:T])
if n_ramp > 0
P_ramp = A_ramp * P
if length(P_ramp_first) == 0
ΔP = [P_ramp[n, t] - P_ramp[n, t % T + 1] for t = 1:T for n = 1:n_ramp]
MOI.add_constraints(optimizer, ΔP, [MOI.GreaterThan(-ΔP_ramp[n])
for t = 1:T for n = 1:n_ramp])
MOI.add_constraints(optimizer, ΔP, [MOI.LessThan(ΔP_ramp[n])
for t = 1:T for n = 1:n_ramp])
else
ΔP = [P_ramp[n, t] - P_ramp[n, t + 1] for t = 1:T-1 for n = 1:n_ramp]
MOI.add_constraints(optimizer, ΔP, [MOI.GreaterThan(-ΔP_ramp[n])
for t = 1:T-1 for n = 1:n_ramp])
MOI.add_constraints(optimizer, ΔP, [MOI.LessThan(ΔP_ramp[n])
for t = 1:T-1 for n = 1:n_ramp])
P_first = [P_ramp[n, 1] for n = 1:n_ramp]
MOI.add_constraints(optimizer, P_first, [MOI.GreaterThan(P_ramp_first[n] - ΔP_ramp[n])
for n = 1:n_ramp])
MOI.add_constraints(optimizer, P_first, [MOI.LessThan(P_ramp_first[n] + ΔP_ramp[n])
for n = 1:n_ramp])
P_last = [P_ramp[n, T] for n = 1:n_ramp]
MOI.add_constraints(optimizer, P_last, [MOI.GreaterThan(P_ramp_last[n] - ΔP_ramp[n])
for n = 1:n_ramp])
MOI.add_constraints(optimizer, P_last, [MOI.LessThan(P_ramp_last[n] + ΔP_ramp[n])
for n = 1:n_ramp])
end
end
quadratic_terms = vcat(
[MOI.ScalarQuadraticTerm(2.0 * quadratic_cost[i,i], P[i, t], P[i, t])
for i = 1:N for t = 1:T],
[MOI.ScalarQuadraticTerm(quadratic_cost[i,j], P[i, t], P[j, t])
for i = 1:N for j = (i+1):N for t = 1:T]
)
affine_terms = [MOI.ScalarAffineTerm(linear_cost[i, t], P[i, t]) for i = 1:N for t = 1:T]
objective = MOI.ScalarQuadraticFunction(quadratic_terms, affine_terms, 0.0)
MOI.set(optimizer, MOI.ObjectiveFunction{MOI.ScalarQuadraticFunction{Float64}}(), objective)
MOI.set(optimizer, MOI.ObjectiveSense(), MOI.MIN_SENSE)
@info " -> optimizing" _group = log_group
MOI.optimize!(optimizer)
if MOI.get(optimizer, MOI.ResultCount()) == 1
@info " -> exporting results" _group = log_group
P_vec_solution = MOI.get(optimizer, MOI.VariablePrimal(), P_vec)
P_solution = reshape(P_vec_solution, (N, T))
return P_solution
end
status = MOI.get(optimizer, MOI.TerminationStatus())
@warn "OPF did not converge: termination status $status" _group = log_group
if debug
@info " -> exporting debug data" _group = log_group
try
DataDrop.store_matrix("debug_quadratic_cost.h5", quadratic_cost)
DataDrop.store_matrix("debug_linear_cost.h5", linear_cost)
DataDrop.store_matrix("debug_P_max.h5", P_max)
DataDrop.store_matrix("debug_P_exp.h5", P_exp)
DataDrop.store_matrix("debug_P_total.h5", P_total)
DataDrop.store_matrix("debug_P_min.h5", P_min)
DataDrop.store_matrix("debug_A_ramp.h5", A_ramp)
DataDrop.store_matrix("debug_P_ramp.h5", ΔP_ramp)
if length(P_ramp_first) > 0
DataDrop.store_matrix("debug_P_ramp_first.h5", P_ramp_first)
DataDrop.store_matrix("debug_P_ramp_last.h5", P_ramp_last)
end
catch
@warn "Failed to export debug data" _group = log_group
end
end
if retry
@info " -> second attempt" _group = log_group
return opf(quadratic_cost, linear_cost, P_max, P_exp, P_total, P_min = P_min,
A_ramp = A_ramp, ΔP_ramp = ΔP_ramp,
P_ramp_first = P_ramp_first, P_ramp_last = P_ramp_last,
log_group = log_group, retry = false, debug = false)
end
throw(ErrorException("OPF did not converge"))
end
function partitioned_opf(partitions::Vector{Int},
quadratic_cost::AbstractArray{<:Real,2}, linear_cost::AbstractArray{<:Real,2},
P_max::AbstractVector{<:Real}, P_exp::AbstractVector{<:Real},
P_total::AbstractVector{<:Real}; P_min::AbstractVector{<:Real} = Real[],
A_ramp::AbstractArray{<:Real,2} = Array{Real}(undef, 0, 0),
ΔP_ramp::AbstractVector{<:Real} = Real[],
P_ramp_first::AbstractVector{<:Real} = Real[], P_ramp_last::AbstractVector{<:Real} = Real[],
P_bounds_factor::Real = 0.1, log_group::String = "",
retry::Bool = true, debug::Bool = true)
if length(partitions) <= 1
return opf(quadratic_cost, linear_cost, P_max, P_exp, P_total, P_min = P_min,
A_ramp = A_ramp, ΔP_ramp = ΔP_ramp,
P_ramp_first = P_ramp_first, P_ramp_last = P_ramp_last,
log_group = log_group, retry = retry, debug = debug)
end
N = length(P_max)
T = length(P_total)
n_ramp = length(ΔP_ramp)
if length(P_min) == 0
P_min = zeros(N)
end
# check dimensions of the input that needs to be partitioned
@assert length(P_exp) == N
@assert length(P_min) == N
@assert size(quadratic_cost) == (N, N)
@assert size(linear_cost) == (N, T)
@assert (size(A_ramp) == (n_ramp, N)) || (n_ramp == 0)
# check that the number of partitions matches the total number of steps
@assert prod(partitions) == T
@assert (P_bounds_factor >= 0) && (P_bounds_factor < 1)
n_partitions = partitions[1]
partition_length = T ÷ n_partitions
counter_width = length(string(n_partitions))
@info ("Partitioning a dataset of $T time steps into $n_partitions chunks "
* "of $partition_length time steps") _group = log_group
partitioned_P_total = reshape(P_total, (partition_length, n_partitions))
aggregated_P_total = dropdims(sum(partitioned_P_total, dims=1), dims=1) / partition_length
partitioned_linear_cost = reshape(linear_cost, (N, partition_length, n_partitions))
aggregated_linear_cost = dropdims(sum(partitioned_linear_cost, dims=2),
dims=2) / partition_length
aggregated_P_max = (1.0 - P_bounds_factor) * P_max + P_bounds_factor * P_exp
aggregated_P_min = (1.0 - P_bounds_factor) * P_min + P_bounds_factor * P_exp
partitioned_P_exp = opf(quadratic_cost, aggregated_linear_cost, aggregated_P_max, P_exp,
aggregated_P_total, P_min = aggregated_P_min, A_ramp = A_ramp, ΔP_ramp = ΔP_ramp,
P_ramp_first = P_ramp_first, P_ramp_last = P_ramp_last,
log_group = log_group * " $(lpad(0, counter_width))/$(n_partitions)",
retry = retry, debug = debug)
partitioned_P_ramp = n_ramp > 0 ? A_ramp * partitioned_P_exp : Real[]
result = Matrix{Float64}(undef, N, 0)
timing = []
for a=1:n_partitions
GC.gc()
if length(timing) > 0
estimated_remaining_time = "Estimated remaining time:"
s = round(Int, (n_partitions - a + 1) * sum(timing) / length(timing))
if s >= 60
m = s ÷ 60
s = s % 60
if m >= 60
h = m ÷ 60
m = m % 60
estimated_remaining_time = estimated_remaining_time * " $h h"
end
estimated_remaining_time = estimated_remaining_time * " $m min"
end
estimated_remaining_time = estimated_remaining_time * " $s s"
@info estimated_remaining_time _group = log_group
end
if n_ramp == 0
partitioned_P_ramp_previous = Real[]
partitioned_P_ramp_next = Real[]
else
if a == 1
partitioned_P_ramp_previous = (length(P_ramp_first) > 0
? P_ramp_first : partitioned_P_ramp[:, end])
else
partitioned_P_ramp_previous = partitioned_P_ramp[:, a - 1]
end
if a == n_partitions
partitioned_P_ramp_next = (length(P_ramp_last) > 0
? P_ramp_last : partitioned_P_ramp[:, 1])
else
partitioned_P_ramp_next = partitioned_P_ramp[:, a + 1]
end
end
partition_result = @timed partitioned_opf(partitions[2:end], quadratic_cost,
partitioned_linear_cost[:,:,a], P_max, partitioned_P_exp[:,a], partitioned_P_total[:,a],
P_min = P_min, A_ramp = A_ramp, ΔP_ramp = ΔP_ramp,
P_ramp_first = partitioned_P_ramp_previous, P_ramp_last = partitioned_P_ramp_next,
log_group = log_group * " $(lpad(a, counter_width))/$(n_partitions)",
retry = retry, debug = debug)
push!(timing, partition_result.time)
result = hcat(result, partition_result.value)
end
return result
end
function compute(directory::String, result_file::String = "P_result",
partitions::AbstractVector{<:Integer} = Integer[], noise_factor::Real = 1; kwargs...)
quadratic_cost = DataDrop.retrieve_matrix("$directory/quadratic_cost.h5")
line_cost = DataDrop.retrieve_matrix("$directory/linear_line_cost.h5")
gen_cost = DataDrop.retrieve_matrix("$directory/linear_gen_cost.h5")
P_max = DataDrop.retrieve_matrix("$directory/P_max.h5")
P_exp = DataDrop.retrieve_matrix("$directory/P_exp.h5")
P_total = DataDrop.retrieve_matrix("$directory/P_total.h5")
if isfile("$directory/A_ramp.h5") && isfile("$directory/ramp_max.h5")
A_ramp = DataDrop.retrieve_matrix("$directory/A_ramp.h5")
ΔP_ramp = DataDrop.retrieve_matrix("$directory/ramp_max.h5")
else
A_ramp = Array{Real}(undef, 0, 0)
ΔP_ramp = Real[]
end
linear_cost = line_cost + noise_factor * gen_cost
result = (length(partitions) == 0
? opf(quadratic_cost, linear_cost,
P_max, P_exp, P_total; A_ramp = A_ramp, ΔP_ramp = ΔP_ramp, kwargs...)
: partitioned_opf(partitions, quadratic_cost, linear_cost,
P_max, P_exp, P_total; A_ramp = A_ramp, ΔP_ramp = ΔP_ramp, kwargs...)
)
if occursin(".h5", result_file) == false
result_file = result_file * ".h5"
end
if occursin("/", result_file) == false
result_file = "$directory/" * result_file
end
@info ("Saving results to file '$(result_file)'") _group = ""
DataDrop.store_matrix(result_file, result)
nothing
end | TemperateOptimalPowerFlow | https://github.com/gillioz/TemperateOptimalPowerFlow.jl.git |
|
[
"MIT"
] | 0.2.0 | d1748496d967022306613c7a90be7509e4047836 | code | 10690 | export prepare_model!, import_model, split_nondispatchable!
export check_balance, balance_model!, setup, scale_down
export get_ordered_gen_ids, get_ordered_line_ids, get_ordered_load_ids, get_ordered_bus_ids
function prepare_model!(network::Dict{String, Any}, default_pexp::Real = 0.5)
# add a list of non-dispatchable generators if it does not exists
if "gen_nd" ∉ keys(network)
network["gen_nd"] = Dict{String, Any}()
end
# compute the lines' susceptance
for line in values(network["branch"])
line["br_b"] = line["br_x"] / (line["br_x"]^2 + line["br_r"]^2)
end
# add a default value for expected production whenever it is missing
for gen in values(network["gen"])
if "pexp" ∉ keys(gen)
gen["pexp"] = default_pexp * gen["pmax"]
end
if "max_ramp_rate" ∉ keys(gen)
gen["max_ramp_rate"] = 0.0
end
end
nothing
end
function import_model(file::String) :: Dict{String, Any}
network = JSON.parsefile(file)
prepare_model!(network)
return network
end
function split_nondispatchable!(network::Dict{String, Any}, nondisp_ids::Vector{String})
nondisp_ids = intersect(nondisp_ids, keys(network["gen"]))
for id ∈ nondisp_ids
network["gen_nd"][id] = network["gen"][id]
delete!(network["gen"], id)
end
nothing
end
function sort_strings(strings::Union{AbstractVector{String}, AbstractSet{String}})
return string.(sort(parse.(Int, strings)))
end
function get_ordered_ids(network::Dict{String, Any}, key::String)
return sort_strings(keys(network[key]))
end
get_ordered_gen_ids(network::Dict{String, Any}) = get_ordered_ids(network, "gen")
get_ordered_bus_ids(network::Dict{String, Any}) = get_ordered_ids(network, "bus")
get_ordered_load_ids(network::Dict{String, Any}) = get_ordered_ids(network, "load")
get_ordered_line_ids(network::Dict{String, Any}) = get_ordered_ids(network, "branch")
function check_balance(network::Dict{String, Any}, loads::AbstractArray{<:Real},
nondispatch_series::AbstractArray{<:Real} = Real[], epsilon::Float64 = 1e-3) :: Bool
production = sum(gen["pexp"] for gen in values(network["gen"]))
if length(nondispatch_series) > 0
production += sum(nondispatch_series) / size(nondispatch_series, 2)
end
consumption = sum(loads) / size(loads, 2)
@info "Checking balance: $production (production) / $consumption (consumption)" _group = ""
return abs(production / consumption - 1) < epsilon
end
function balance_model!(network::Dict{String, Any}, loads::AbstractArray{<:Real},
nondispatch_series::AbstractArray{<:Real} = Real[], epsilon::Float64 = 1e-3)
gen_ids = get_ordered_gen_ids(network)
gen_pmax = [network["gen"][id]["pmax"] for id in gen_ids]
total_gen_capacity = sum(gen_pmax)
total_load = sum(loads) / size(loads, 2)
if length(nondispatch_series) > 0
total_load -= sum(nondispatch_series) / size(nondispatch_series, 2)
end
usage = total_load / total_gen_capacity
@info "Balancing expected production at $(usage / 100) % of the total capacity" _group = ""
if usage >= 1
throw(ErrorException("Total production capacity insufficient to balance the loads"))
end
for gen in values(network["gen"])
gen["pexp"] = usage * gen["pmax"]
end
nothing
end
function setup(output_directory::String, network::Dict{String, Any}, loads::AbstractArray{<:Real},
gen_costs::AbstractArray{<:Real}, nondispatch_series::AbstractArray{<:Real} = Real[];
overwrite::Bool = false)
if !check_balance(network, loads, nondispatch_series)
throw(ErrorException("The balance between production and consumptions is not respected"))
end
if isdir(output_directory)
if overwrite
@info "Overwriting directory '$(output_directory)'" _group = ""
rm(output_directory, recursive = true)
mkdir(output_directory)
else
throw(ErrorException("Cannot overwrite existing directory '$(output_directory)'"))
end
else
@info "Creating directory '$(output_directory)'" _group = ""
mkdir(output_directory)
end
@info "Loading network" _group = ""
N_buses = length(network["bus"])
N_loads = length(network["load"])
N_gens = length(network["gen"])
N_lines = length(network["branch"])
N_nondispatch = length(network["gen_nd"])
T = size(loads, 2)
@assert size(loads) == (N_loads, T)
@assert size(gen_costs) == (N_gens, T)
if N_nondispatch > 0
@assert size(nondispatch_series) == (N_nondispatch, T)
end
bus_ids = get_ordered_ids(network, "bus")
gen_ids = get_ordered_ids(network, "gen")
load_ids = get_ordered_ids(network, "load")
line_ids = get_ordered_ids(network, "branch")
nondispatch_ids = get_ordered_ids(network, "gen_nd")
bus_ids_map = Dict(id => i for (i, id) in enumerate(bus_ids))
gen_ids_map = Dict(id => i for (i, id) in enumerate(gen_ids))
@info "Computing susceptance matrix" _group = ""
# incidence matrix
lines_from_bus = [bus_ids_map[string(network["branch"][id]["f_bus"])] for id ∈ line_ids]
lines_to_bus = [bus_ids_map[string(network["branch"][id]["t_bus"])] for id ∈ line_ids]
M = sparse([lines_from_bus; lines_to_bus], [1:N_lines; 1:N_lines],
[-ones(N_lines); ones(N_lines)], N_buses, N_lines)
b = [network["branch"][id]["br_b"] for id ∈ line_ids];
B = M * Diagonal(b)
DataDrop.store_matrix("$(output_directory)/susceptance.h5", b)
@info "Computing PTDF matrix (this may take some time)" _group = ""
# pseudo-inverse
Bi = pinv(Matrix(B))
# PTDF matrix
L = Diagonal(b) * Bi
DataDrop.store_matrix("$(output_directory)/PTDF_matrix.h5", L)
@info "Distributing generator on buses" _group = "" _group = ""
gen_buses = [bus_ids_map[string(network["gen"][id]["gen_bus"])] for id ∈ gen_ids]
A_gen = sparse(gen_buses, 1:N_gens, ones(N_gens), N_buses, N_gens)
DataDrop.store_matrix("$(output_directory)/A_gen.h5", A_gen)
@info "Distributing loads on buses" _group = "" _group = ""
load_buses = [bus_ids_map[string(network["load"][id]["load_bus"])] for id ∈ load_ids]
A_load = sparse(load_buses, 1:N_loads, ones(N_loads), N_buses, N_loads)
injections = - A_load * loads
DataDrop.store_matrix("$(output_directory)/A_load.h5", A_load)
if N_nondispatch > 0
@info "Distributing non-dispatchable generators on buses" _group = "" _group = ""
A_nondispatch = sparse(
indexin([string(network["gen_nd"][id]["gen_bus"]) for id in nondispatch_ids], bus_ids),
1:N_nondispatch, ones(N_nondispatch), length(bus_ids), N_nondispatch)
injections = A_nondispatch * nondispatch_series - A_load * loads
DataDrop.store_matrix("$(output_directory)/A_nondispatch.h5", A_nondispatch)
DataDrop.store_matrix("$(output_directory)/P_nondispatch.h5", nondispatch_series)
end
@info "Computing max capacity for each generator" _group = ""
gen_pmax = [convert(Float64, network["gen"][id]["pmax"]) for id ∈ gen_ids]
DataDrop.store_matrix("$(output_directory)/P_max.h5", gen_pmax)
@info "Computing expected production for each generator" _group = ""
gen_pexp = [convert(Float64, network["gen"][id]["pexp"]) for id ∈ gen_ids]
DataDrop.store_matrix("$(output_directory)/P_exp.h5", gen_pexp)
@info "Computing thermal limits" _group = ""
thermal_limits = [convert(Float64, network["branch"][id]["rate_a"]) for id ∈ line_ids]
DataDrop.store_matrix("$(output_directory)/thermal_limits.h5", thermal_limits)
@info "Computing quadratic line costs" _group = ""
line_costs = 1. ./ thermal_limits
LA = L * A_gen
quadratic_cost = LA' * (line_costs .* LA)
DataDrop.store_matrix("$(output_directory)/quadratic_cost.h5", quadratic_cost)
@info "Computing linear line costs" _group = ""
linear_cost = 2 * LA' * (line_costs .* L * injections)
DataDrop.store_matrix("$(output_directory)/linear_line_cost.h5", linear_cost)
@info "Computing linear generation costs" _group = ""
DataDrop.store_matrix("$(output_directory)/linear_gen_cost.h5", gen_costs)
@info "Computing total load constraints" _group = ""
DataDrop.store_matrix("$(output_directory)/P_load.h5", loads)
P_total = sum(loads, dims=1)[1, :]
if N_nondispatch > 0
P_total -= sum(nondispatch_series, dims=1)[1, :]
end
DataDrop.store_matrix("$(output_directory)/P_total.h5", P_total)
@info "Computing ramp constraints" _group = ""
ramp_gen_ids = [id for id in gen_ids if network["gen"][id]["max_ramp_rate"] > 0]
N_ramp = length(ramp_gen_ids)
if N_ramp > 0
A_ramp = sparse(1:N_ramp, [gen_ids_map[id] for id ∈ ramp_gen_ids], ones(N_ramp), N_ramp, N_gens)
DataDrop.store_matrix("$(output_directory)/A_ramp.h5", A_ramp)
ramp_max = [network["gen"][id]["max_ramp_rate"] for id in ramp_gen_ids]
DataDrop.store_matrix("$(output_directory)/ramp_max.h5", ramp_max)
end
@info "Recording generators IDs" _group = ""
all_gen_ids = vcat(gen_ids, nondispatch_ids)
DataDrop.store_matrix("$(output_directory)/gen_ids.h5", all_gen_ids)
nothing
end
function scale_down_file(file::String, new_timesteps::Int)
data = DataDrop.retrieve_matrix(file)
data_size = size(data)
dims = length(data_size)
old_timesteps = data_size[end]
@info "Scaling down file '$file' from $(old_timesteps) to $(new_timesteps) time steps" _group = ""
if old_timesteps % new_timesteps != 0
throw(ArgumentError("The number of time steps ($(old_timesteps)) " *
"cannot be divided into $(new_timesteps) parts"))
end
n = old_timesteps ÷ new_timesteps
if dims == 1
data = dropdims(sum(reshape(data, (n, new_timesteps)), dims=1), dims=1) ./ n
elseif dims == 2
data = dropdims(sum(reshape(data, (:, n, new_timesteps)), dims=2), dims=2) ./ n
else
throw(ArgumentError("Only arrays with up to two dimensions are supported"))
end
rm(file)
DataDrop.store_matrix(file, data)
nothing
end
function scale_down(data_directory::String, new_timesteps::Int)
scale_down_file("$(data_directory)/P_total.h5", new_timesteps)
scale_down_file("$(data_directory)/linear_line_cost.h5", new_timesteps)
scale_down_file("$(data_directory)/linear_gen_cost.h5", new_timesteps)
scale_down_file("$(data_directory)/P_load.h5", new_timesteps)
if isfile("$(data_directory)/P_nondispatch.h5")
scale_down_file("$(data_directory)/P_nondispatch.h5", new_timesteps)
end
nothing
end
| TemperateOptimalPowerFlow | https://github.com/gillioz/TemperateOptimalPowerFlow.jl.git |
|
[
"MIT"
] | 0.2.0 | d1748496d967022306613c7a90be7509e4047836 | code | 6751 | using Test
using TemperateOptimalPowerFlow
using PowerModels
using Ipopt
@testset "TemperateOptimalPowerFlow.jl" begin
@testset "prepare_model" begin
# import MatPower test case
network = parse_file("case3.m")
@test isa(network, Dict)
@test "gen_nd" ∉ keys(network)
# prepare the network
prepare_model!(network)
# check the presence of nondispatchable generators category
@test "gen_nd" in keys(network)
@test length(network["gen_nd"]) == 0
# check the presence of the lines' susceptance
for line in values(network["branch"])
@test "br_b" in keys(line)
end
# check the presence of the generators' exprected production and max ramp rate
for gen in values(network["gen"])
@test "pexp" in keys(gen)
@test "max_ramp_rate" in keys(gen)
end
end
@testset "split_nondispatchable" begin
# import the Swiss model
network = import_model("switzerland.json")
@test isa(network, Dict)
# verify the presence of generators
@test "gen" in keys(network)
@test "gen_nd" in keys(network)
gens = network["gen"]
@test isa(gens, Dict)
n_gens = length(network["gen"])
@test n_gens > 0
@test length(network["gen_nd"]) == 0
# separate nuclear generators from the rest
split_nondispatchable!(network, ["908", "917", "921", "943"])
@test length(network["gen"]) == n_gens - 4
@test isa(network["gen_nd"], Dict)
@test length(network["gen_nd"]) == 4
end
@testset "get_ordered_ids" begin
# import MatPower test case
network = parse_file("case3.m")
@test isa(network, Dict)
# get IDS
@test get_ordered_gen_ids(network) == ["1", "2", "3"]
@test get_ordered_bus_ids(network) == ["1", "2", "3"]
@test get_ordered_line_ids(network) == ["1", "2", "3"]
@test get_ordered_load_ids(network) == ["1", "2", "3"]
end
@testset "get_optimzer" begin
optimizer = get_optimizer()
@test isa(optimizer, Ipopt.Optimizer)
silent_optimizer = get_silent_optimizer()
@test isa(silent_optimizer, Ipopt.Optimizer)
end
@testset "check_balance" begin
# import MatPower test case
network = parse_file("case3.m")
prepare_model!(network)
# create a random time series for the loads and generation costs
T = 4
loads = 0.9 .+ 0.2 * rand(Float64, (3,T)) # random numbers between 0.9 and 1.1
# verify that the power balance is not respected
@test !check_balance(network, loads)
# adjust expected production to match the loads
balance_model!(network, loads)
# verify that the power balance is respected
@test check_balance(network, loads)
end
@testset "setup" begin
# clear data directory
dir = "data"
if isdir(dir)
rm(dir, recursive=true)
end
# import MatPower test case
network = parse_file("case3.m")
prepare_model!(network)
# create a random time series for the loads and generation costs
T = 24
loads = 0.9 .+ 0.2 * rand(Float64, (3,T)) # random numbers between 0.9 and 1.1
gen_costs = -1.0 .+ 2.0 * rand(Float64, (3,T)) # random numbers between -1 and 1
# adjust expected production to match the loads
balance_model!(network, loads)
# setup the computation
setup(dir, network, loads, gen_costs)
# verify the presence of all the relevant files
setup_files = ["A_gen.h5", "A_load.h5", "gen_ids.h5", "linear_gen_cost.h5",
"linear_line_cost.h5", "P_exp.h5", "P_load.h5", "P_max.h5", "PTDF_matrix.h5",
"P_total.h5", "quadratic_cost.h5", "susceptance.h5", "thermal_limits.h5"]
@test issetequal(readdir(dir), setup_files)
# add ramp constraints to one generator and re-setup the computation
network["gen"]["1"]["max_ramp_rate"] = 1.0
setup(dir, network, loads, gen_costs, overwrite=true)
# verify the presence of all the relevant files
setup_files = vcat(setup_files, ["A_ramp.h5", "ramp_max.h5"])
@test issetequal(readdir(dir), setup_files)
# setup another computation with one non-dispatchable generator
split_nondispatchable!(network, ["2"])
gen_costs = -1.0 .+ 2.0 * rand(Float64, (2,T)) # random numbers between -1 and 1
gen_series = 0.9 .+ 0.2 * rand(Float64, (1,T)) # random numbers between 0.9 and 1.1
balance_model!(network, loads, gen_series)
setup(dir, network, loads, gen_costs, gen_series, overwrite=true)
# verify the presence of all the relevant files
setup_files = vcat(setup_files, ["A_nondispatch.h5", "P_nondispatch.h5"])
@test issetequal(readdir(dir), setup_files)
# cleanup
rm(dir, recursive=true)
end
@testset "compute" begin
# clear data directory
dir = "data"
if isdir(dir)
rm(dir, recursive=true)
end
# import MatPower test case
network = parse_file("case3.m")
prepare_model!(network)
# create a random time series for the loads and generation costs
T = 4
loads = 0.9 .+ 0.2 * rand(Float64, (3,T)) # random numbers between 0.9 and 1.1
gen_costs = -1.0 .+ 2.0 * rand(Float64, (3,T)) # random numbers between -1 and 1
# adjust expected production to match the loads
balance_model!(network, loads)
# setup
setup(dir, network, loads, gen_costs)
# compute
compute(dir)
# verify the presence of the result file
@test isfile("$dir/P_result.h5")
# retrieve gen results and verify their validity
gens = retrieve_gen_results(dir)
@test size(gens) == (3, T)
@test all(gens .>= 0)
gen_ids = get_ordered_gen_ids(network)
gen_pmax = [network["gen"][id]["pmax"] for id in gen_ids]
@test all(gens .<= gen_pmax)
# verify the energy balance at every bus
injections = retrieve_injections(dir)
@test all(abs.(sum(injections, dims = 1)) .<= 1e-6)
# retrieve line results and verify their validity
lines = retrieve_line_flows(dir)
@test size(lines) == (3, T)
rates = retrieve_line_rates(dir)
@test size(lines) == (3, T)
@test all(rates .>= 0)
# cleanup
rm(dir, recursive=true)
end
end
| TemperateOptimalPowerFlow | https://github.com/gillioz/TemperateOptimalPowerFlow.jl.git |
|
[
"MIT"
] | 0.2.0 | d1748496d967022306613c7a90be7509e4047836 | docs | 5099 | TOPF: Temperate Optimal Power Flow
==================================
[](https://github.com/gillioz/TemperateOptimalPowerFlow.jl/actions/workflows/CI.yml?query=branch%3Amain)
This package implements a "temperate" Optimal Power Flow (OPF) algorithm
that dispatches production sources in a power system while disfavoring heavily-loaded lines.
Line cost function
------------------
The core of the algorithm is to assign a cost to each line of the power grid
that is proportional to the square of the line's loading rate.
In this way, the optimal power flow becomes a convex optimization problem
that can be solved with standard methods.
Given the power $P_i$ flowing through a line with index $i$,
and the thermal limit of the line $P_i^{th}$,
the loading rate $R_i$ of the line is given by the formula
$R_i = | P_i | / P_i^{th}$
We define the cost associated with line $i$ to be the square of the loading rate,
weighted by the line's thermal limit:
$P_i^{th} R_i^2$
Using the definition of the loading rate, this is equivalent to:
$P_i^2 / P_i^{th}$
This cost is independent of the sign of the power $P_i$, which depends on the line's direction.
Other features
--------------
In addition to the quadratic line cost, a conventional, linear production cost can be associated
with each generator in order to model the contingencies of power production
and introduce some realistic noise in the optimisation process.
The TOPF algorithm also supports constraints that ensures a given total production
over a certain period of time for every individual generator.
Installation
------------
The package can be installed with
```julia
] add "https://github.com/gillioz/TemperateOptimalPowerFlow.jl"
```
You can test the installation by running
```julia
] test TemperateOptimalPowerFlow
```
Usage
-----
To begin, import a model in [MatPower](https://www.pserc.cornell.edu/matpower/)
or [PowerModels](https://lanl-ansi.github.io/PowerModels.jl/stable/network-data/) format.
For instance, working the package's directory, one can use:
```julia
using TemperateOptimalPowerFlow
network = import_model("test/switzerland.json")
```
or
```julia
using TemperateOptimalPowerFlow, PowerModels
network = parse_file("test/case3.m")
prepare_model!(network)
```
If the model is imported with the *PowerModels* `parse_file` method,
it is necessary to run the command `prepare_model!` that adds some features to the model.
In particular, it ensures that the model contains an *expected generation value* `pexp`
for each generator, which must be a fraction of the generator's capacity `pmax`
(if missing, this is set to 50% of the capacity by default).
The optimal power flow computation is then setup with the command
```julia
setup(directory, network, loads, gen_costs)
```
where
- `directory` is a path to a directory to be created, in which computation files will be placed;
- `network` is the network object imported before;
- `loads` is a matrix that contain time series for each load of the model, arranged as rows;
- `gen_costs` is a similar matrix with one row for each generator of the model,
containing the variable generation cost of that generator.
Several files are generated in the relevant directory.
To perform the actual optimal power flow computation,
one needs to import an optimizer such as [Gurobi](https://www.gurobi.com/) (commercial)
or [Ipopt](https://github.com/coin-or/Ipopt) (open source),
or otherwise provide a `get_optimizer()` method that returns an optimizer
in the [MathOptInterface](https://jump.dev/MathOptInterface.jl/stable/) format.
Then the computation can be launched with
```julia
using Ipopt
compute(directory)
```
**WARNING**: For large models and/or long time series the computation can be slow (several hours!) and memory-intensive.
It is recommended to partition the optimal power flow computation into smaller parts.
For instance, a time series of 8736 time steps (364 days x 24 hours) can be partitioned into
52 weeks of 168 time steps using
```julia
compute(directory, "P_result_52x168", [52, 168])
```
or partitioned further into 13 "months" of 28 days of 24 hours as
```julia
compute(directory, "P_result_13x28x24", [13, 28, 24])
```
The second argument in both cases indicates the name of the result file.
Once the computation is done, the results can be accessed with
```julia
retrieve_gen_results(directory, "P_result_13x28x24")
```
returning a matrix of time series in which each row corresponds to a generator of the model.
The ordered list of generators can be obtained with
```julia
get_ordered_gen_ids(network)
```
Similarly, the power flowing through the lines of the network can be accessed with
```julia
retrieve_line_flows(directory, "P_result_13x28x24")
```
where the rows correspond to the line IDs of
```julia
get_ordered_line_ids(network)
```
A more complete description of the package's possibilities can be found in the
[PowerData repository](https://github.com/GeeeHesso/PowerData/tree/main/run).
| TemperateOptimalPowerFlow | https://github.com/gillioz/TemperateOptimalPowerFlow.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 1087 | using Documenter: Documenter, makedocs, deploydocs
using CommonDataModel
using Literate
Literate.markdown(
"docs/src/tutorial1.jl","docs/src",
execute = true,
documenter = true,
# We add the credit to Literate.jl the footer
credit = false,
)
if get(ENV, "CI", "false") == "true"
# remove datafile on CI
rm("docs/src/sst.day.mean.2023.nc")
end
makedocs(;
modules=[CommonDataModel],
repo="https://github.com/JuliaGeo/CommonDataModel.jl/blob/{commit}{path}#{line}",
sitename="CommonDataModel.jl",
format=Documenter.HTML(;
prettyurls=get(ENV, "CI", "false") == "true",
canonical="https://juliageo.github.io/CommonDataModel.jl",
assets=String[],
footer = "Powered by [Documenter.jl](https://github.com/JuliaDocs/Documenter.jl), [Literate.jl](https://github.com/fredrikekre/Literate.jl) and the [Julia Programming Language](https://julialang.org/)"
),
pages=[
"Home" => "index.md",
"Tutorials" => "tutorial1.md",
],
)
deploydocs(;
repo="github.com/JuliaGeo/CommonDataModel.jl",
)
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 6362 | # # Select, group and reduce data sets with CommonDataModel
#
# As an example we use the NOAA OISST v2 dataset available at:
# [https://psl.noaa.gov/thredds/fileServer/Datasets/noaa.oisst.v2.highres/sst.day.mean.2023.nc](https://psl.noaa.gov/thredds/fileServer/Datasets/noaa.oisst.v2.highres/sst.day.mean.2023.nc)
using CommonDataModel: @select, @CF_str, @groupby, groupby
using Dates
using Downloads: download
using CairoMakie # use GLMakie for interactive plots
#using GLMakie
using IntervalSets
using NCDatasets
using Statistics
# Some helper functions for plotting with Makie for plotting maps and timeseries.
function nicemaps(v; timeindex = 1, lon = v["lon"][:], lat = v["lat"][:], title = nothing)
fig, ax, hm = heatmap(lon,lat,v[:,:,timeindex],aspect_ratio = 1/cosd(mean(lat)))
if !isnothing(title)
ax.title[] = title
end
Colorbar(fig[1,2],hm)
return fig
end
function nicetimeseries(v::AbstractVector; time = v["time"][:], title = nothing,
timefmt = "yyyy-mm-dd")
fig, ax, ln = lines(Dates.value.(time),v[:])
if !isnothing(title)
ax.title[] = title
end
timeticks = DateTime.(2023,1:2:12,1)
ax.xticks = Dates.value.(timeticks),Dates.format.(timeticks,timefmt)
ax.xticklabelrotation = π/4
return fig
end
# Download the data file (unless already downloaded)
# The dataset contains the variables `lon` (longitude), `lat` (latitude), `time`
# and `sst` (sea surface temperature).
url = "https://psl.noaa.gov/thredds/fileServer/Datasets/noaa.oisst.v2.highres/sst.day.mean.2023.nc"
fname = "sst.day.mean.2023.nc"
if !isfile(fname)
download(url,fname)
end
# ## Select a subset by values from coordinate variables
#
# Open the dataset and access the variable `sst`. Select the domain from
# 300°E to 360°E and 0°N to 46°N and the closest time instance to the
# 1 April 2023.
ds = NCDataset(fname)
ncsst = ds["sst"]
ncsst2 = @select(ncsst,300 <= lon <= 360 && 0 <= lat <= 46 && time ≈ DateTime(2023,4,1))
nicemaps(ncsst2, title = "NA SST")
# One can also select a subset by indices and by values. Here we load the
# first time instance and the domain from 300°E to 360°E and 0°N to 46°N
ncsst_first = view(ncsst,:,:,1)
ncsst_na = @select(ncsst_first,300 <= lon <= 360 && 0 <= lat <= 46)
nicemaps(ncsst_na)
# Select all data from a given month
ncsst_march = @select(ncsst,Dates.month(time) == 3)
nicemaps(ncsst_march, timeindex = 1, title = "SST 1st March 2023")
# Select multiple months using e.g. an interval (from [IntervalSets](https://github.com/JuliaMath/IntervalSets.jl)).
# ∈ can be typed by writing `\in` directly followed by the TAB key.
ncsst_march_april = @select(ncsst,Dates.month(time) ∈ 3..4)
nicemaps(ncsst_march_april)
# Use julia functions to extract data; here the `abs` function
# polar regions north of 60°N and south of 60°S
ncsst_polar = @select(ncsst,abs(lat) > 60)
fig, ax, hm = heatmap(ncsst_polar[:,:,1])
ax.title[] = "regions north of 60°N and south of 60°S ($(ncsst_polar[:time][1]))"
Colorbar(fig[1,2],hm)
# Extract the time series of the closest point to a given point
ncsst_timeseries = @select(ncsst,lon ≈ 330 && lat ≈ 38)
lon = ncsst_timeseries["lon"][:]
lat = ncsst_timeseries["lat"][:]
nicetimeseries(ncsst_timeseries, title = "SST at $(lon) °E and $(lat) °N")
# Extract the time series of the closest point with a specified tolerance
# If there is no data nearby an empty array is returned
ncsst_outside = @select(ncsst,lon ≈ 330 && lat ≈ 93 ± 0.1)
isempty(ncsst_outside)
size(ncsst_outside)
# Rather than selecting SST based on coordinates, we can also do the reverse:
# select the longitude based on SST.
# Find the longitudes where the SST exceeds 30 at the equator.
# `sst` can contain missing values (e.g. on land).
# `coalesce` is necessary here to replace the missing values by false in the boolean
# expression.
ds_equator = @select(ds,lat ≈ 0 && time ≈ DateTime(2023,1,1))
lon_equator = @select(ds_equator,coalesce(sst > 30,false))["lon"]
# The first 3 longitude where SST exceeds 30°C at the equator for 2023-01-01
lon_equator[1:3]
# ## Grouping and reducing
#
# With the function [`groupby`](@ref CommonDataModel.groupby) and macro [`@groupby`](@ref CommonDataModel.@groupby) we can group the variable by a given criteria.
# For each group, we can then apply a reducting function (`mean`, `sum`, `std`, ...).
# For example group the SST by month and average per month:
sst_mean = mean(@groupby(ncsst,Dates.Month(time)))
# Instead of using the macro one can also use the function `groupby`:
sst_mean = mean(groupby(ncsst,:time => Dates.Month))
nicemaps(sst_mean, timeindex = 1, title = "Mean January SST")
# Use custom julia function for grouping:
# The [Atlantic hurricane season](https://en.wikipedia.org/w/index.php?title=Atlantic_hurricane_season&oldid=1189144955) is the period in a year, from June 1 through November 30, when tropical or subtropical cyclones are most likely to form in the North Atlantic Ocean.
# The data will be grouped into two cases: `false` (time outside the Atlantic hurricane season) and `true` (time is within the Atlantic hurricane season).
# We plot only the 2nd group.
sst_na = @select(ncsst,300 <= lon <= 360 && 0 <= lat <= 46)
sst_hs = mean(@groupby(sst_na,DateTime(year(time),6,1) <= time <= DateTime(year(time),11,30)))
nicemaps(sst_hs,timeindex = 2, title = "mean SST during the Atlantic hurricane season")
# Use a user defined function `is_atlantic_hurricane_season` without the `@groupby` macro:
is_atlantic_hurricane_season(time) =
DateTime(year(time),6,1) <= time <= DateTime(year(time),11,30)
sst_std_hs = std(groupby(sst_na,:time => is_atlantic_hurricane_season));
nicemaps(sst_std_hs,timeindex = 2, title = "std SST during the Atlantic hurricane season")
# Use a custom aggregation function to
# estimate the probability that the temperature exceeds 26°C during
# the Atlantic hurricane season
using CommonDataModel: GroupedVariable
prob_hot(x; dims=:) = mean(coalesce.(x .> 26,false); dims=dims)
prob_hot(gv::GroupedVariable) = reduce(prob_hot,gv)
is_atlantic_hurricane_season(time) =
DateTime(year(time),6,1) <= time <= DateTime(year(time),11,30)
sst_my_mean = prob_hot(groupby(ncsst,:time => is_atlantic_hurricane_season));
nicemaps(sst_my_mean,timeindex=2, title = "probability(temp. > 26°C) during Atlantic hurricane season")
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 6790 | module CatArrays
using Base
# computes the shape of the array of size `sz` after applying the indexes
# size(a[indexes...]) == _shape_after_slice(size(a),indexes...)
# the difficulty here is to make the size inferrable by the compiler
@inline _shape_after_slice(sz,indexes...) = __sh(sz,(),1,indexes...)
@inline __sh(sz,sh,n,i::Integer,indexes...) = __sh(sz,sh, n+1,indexes...)
@inline __sh(sz,sh,n,i::Colon, indexes...) = __sh(sz,(sh...,sz[n]), n+1,indexes...)
@inline __sh(sz,sh,n,i, indexes...) = __sh(sz,(sh...,length(i)),n+1,indexes...)
@inline __sh(sz,sh,n) = sh
mutable struct CatArray{T,N,M,TA} <: AbstractArray{T,N} where TA <: AbstractArray
# dimension over which the sub-arrays are concatenated
dim::Int
# tuple of all sub-arrays
arrays::NTuple{M,TA}
# offset indices of every subarrays in the combined array
# (0-based, i.e. 0 = no offset)
offset::NTuple{M,NTuple{N,Int}}
# size of the combined array
sz::NTuple{N,Int}
end
#=
C = CatArray(dim,array1,array2,...)
Create a concatenated array view from a list of arrays. Individual
elements can be accessed by subscribs
=#
function CatArray(dim::Int,arrays...)
M = length(arrays)
# number of dimensions
N = ndims(arrays[1])
if dim > N
N = dim
end
# check if dimensions are consistent
for i = 2:M
for j = 1:N
if j !== dim
if size(arrays[i],j) !== size(arrays[1],j)
error("Array number $i has inconsistent size $(size(arrays[i]))")
end
end
end
end
# offset of each sub-array
countdim = 0
offset = ntuple(M) do i
off = ntuple(j -> (j == dim ? countdim : 0), N)
countdim += size(arrays[i],dim)
off
end
# size of concatenated array
sz = ntuple(j -> (j == dim ? countdim : size(arrays[1],j)), N)
TA = typeof(arrays[begin])
T = eltype(arrays[begin])
for i = (firstindex(arrays)+1):lastindex(arrays)
T = promote_type(T,eltype(arrays[i]))
TA = promote_type(TA,typeof(arrays[i]))
end
return CatArray{T,N,M,TA}(
dim,
arrays,
offset,
sz)
end
function load!(CA::CatArray{T,N},B,idx...) where {T,N}
idx_global_local = index_global_local(CA,idx)
for (array,(idx_global,idx_local)) in zip(CA.arrays,idx_global_local)
if valid_local_idx(idx_local...)
# get subset from subarray
subset = array[idx_local...]
B[idx_global...] .= subset
end
end
return B
end
function Base.getindex(CA::CatArray{T,N},idx::Integer...) where {T,N}
checkbounds(CA,idx...)
idx_global_local = index_global_local(CA,idx)
B = Ref{T}()
for (array,(idx_global,idx_local)) in zip(CA.arrays,idx_global_local)
if valid_local_idx(idx_local...)
B[] = array[idx_local...]
end
end
return B[]
end
function Base.getindex(CA::CatArray{T,N},idx...) where {T,N}
checkbounds(CA,idx...)
sz = _shape_after_slice(size(CA),idx...)
B = Array{T,length(sz)}(undef,sz...)
load!(CA,B,idx...)
return B
end
Base.size(CA::CatArray) = CA.sz
function valid_local_idx(local_idx::Integer,local_idx_rest...)
return (local_idx > 0) && valid_local_idx(local_idx_rest...)
end
function valid_local_idx(local_idx::AbstractVector,local_idx_rest...)
return (length(local_idx) > 0) && valid_local_idx(local_idx_rest...)
end
# stop condition
valid_local_idx() = true
# iterate thought all indices by peeling the first value of a tuple off
# which results in better type stability
function gli(offset,subarray,idx)
idx_global_tmp,idx_local_tmp = _gli(offset,subarray,1,(),(),idx...)
return idx_global_tmp,idx_local_tmp
end
function _gli(offset,subarray,i,idx_global,idx_local,idx::Integer,idx_rest...)
# rebase subscribt
idx_offset = idx - offset[i]
# only indeces within bounds of the subarray
if !(1 <= idx_offset <= size(subarray,i))
idx_offset = -1
end
# scalar indices are not part of idx_global (as they are dropped)
return _gli(offset,subarray,i+1,idx_global,(idx_local...,idx_offset),idx_rest...)
end
function _gli(offset,subarray,i,idx_global,idx_local,idx::Colon,idx_rest...)
idx_global_tmp = offset[i] .+ (1:size(subarray,i))
idx_local_tmp = 1:size(subarray,i)
return _gli(offset,subarray,i+1,
(idx_global...,idx_global_tmp),
(idx_local..., idx_local_tmp),idx_rest...)
end
function _gli(offset,subarray,i,idx_global,idx_local,idx::AbstractRange,idx_rest...)
# within bounds of the subarray
within(j) = 1 <= j <= size(subarray,i)
# rebase subscript
idx_offset = idx .- offset[i]
n_within = count(within,idx_offset)
if n_within == 0
idx_local_tmp = 1:0
idx_global_tmp = 1:0
else
# index for getting the data from the local array
idx_local_tmp = idx_offset[findfirst(within,idx_offset):findlast(within,idx_offset)]
idx_global_tmp = (1:n_within) .+ (findfirst(within,idx_offset) - 1)
end
return _gli(offset,subarray,i+1,
(idx_global...,idx_global_tmp),
(idx_local..., idx_local_tmp),idx_rest...)
end
function _gli(offset,subarray,i,idx_global,idx_local,idx::Vector{T},idx_rest...) where T <: Integer
# within bounds of the subarray
within(j) = 1 <= j <= size(subarray,i)
# rebase subscribt
idx_offset = idx .- offset[i]
# index for getting the data from the local array
idx_local_tmp = filter(within,idx_offset)
idx_global_tmp = filter(i -> within(idx_offset[i]),1:length(idx))
return _gli(offset,subarray,i+1,
(idx_global...,idx_global_tmp),
(idx_local..., idx_local_tmp),idx_rest...)
end
# stop condition
# all indices have been processed
_gli(offset,subarray,i,idx_global,idx_local) = (idx_global,idx_local)
function index_global_local(CA::CatArray{T,N,M,TA},idx) where {T,N,M,TA}
# number of indices must be equal to dimension
@assert(length(idx) == N)
idx_global_local = ntuple(j -> gli(CA.offset[j],CA.arrays[j],idx),M)
return idx_global_local
end
function Base.setindex!(CA::CatArray{T,N},data,idx...) where {T,N}
idx_global_local = index_global_local(CA,idx)
@debug ind,idx_global,idx_local,sz
for (array,(idx_global,idx_local)) in zip(CA.arrays,idx_global_local)
if valid_local_idx(idx_local...)
subset = @view data[idx_global...]
@debug idx_local
# set subset in array
array[idx_local...] = subset
end
end
return data
end
# load all the data at once
Base.Array(CA::CatArray{T,N}) where {T,N} = CA[ntuple(i -> :, Val(N))...]
end
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 1069 | module CommonDataModel
using Base.Broadcast: Broadcasted, BroadcastStyle, DefaultArrayStyle
using CFTime
using Dates
using Printf
using Preferences
using DataStructures
import Base:
LogicalIndex,
checkbounds,
close,
collect,
display,
filter,
getindex,
in,
isopen,
iterate,
ndims,
reduce,
show,
size,
write
import Statistics
import Statistics:
maximum,
mean,
median,
minimum,
std,
sum,
var
include("CatArrays.jl")
include("types.jl")
include("dataset.jl")
include("variable.jl")
include("cfvariable.jl")
include("attribute.jl")
include("dimension.jl")
include("cfconventions.jl")
include("multifile.jl")
include("defer.jl")
include("subvariable.jl")
include("select.jl")
include("aggregation.jl")
include("groupby.jl")
include("rolling.jl")
include("memory_dataset.jl")
end # module CommonDataModel
# LocalWords: AbstractDataset NetCDF GRIB ds AbstractVariable
# LocalWords: varname dimnames iterable attribnames attrib dataset
# LocalWords: groupnames AbstractArray
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 1624 |
aggregator(::Type{typeof(var)}) = VarianceWelfordAggregation
aggregator(::Type{typeof(maximum)}) = MaxAggregation
aggregator(::Type{typeof(minimum)}) = MinAggregation
struct VarianceWelfordAggregation{Ti,T}
count::Ti
mean::T
M2::T
end
function VarianceWelfordAggregation(T)
VarianceWelfordAggregation{Int,T}(0,zero(T),zero(T))
end
# Welford's online algorithm
@inline function update(ag::VarianceWelfordAggregation{Ti,T}, new_value) where {Ti,T}
count = ag.count
mean = ag.mean
M2 = ag.M2
count += 1
delta = new_value - mean
mean += delta / count
delta2 = new_value - mean
M2 += delta * delta2
return VarianceWelfordAggregation{Ti,T}(count, mean, M2)
end
function result(ag::VarianceWelfordAggregation)
sample_variance = ag.M2 / (ag.count - 1)
return sample_variance
end
for (funAggregation,fun) in ((:MaxAggregation,max),(:MinAggregation,min))
@eval begin
struct $funAggregation{T}
result::T
init::Bool
end
function $funAggregation(T)
$funAggregation{T}(zero(T),false)
end
@inline function update(ag::$funAggregation{T}, new_value) where T
if ag.init
return $funAggregation{T}(max(ag.result,new_value),true)
else
return $funAggregation{T}(new_value,true)
end
end
function result(ag::$funAggregation)
if ag.init
return ag.result
else
error("reducing over an empty collection is not allowed")
end
end
end
end
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 3234 | """
CommonDatamodel.attribnames(ds::Union{AbstractDataset,AbstractVariable})
Return an iterable of all attribute names in `ds`.
"""
attribnames(ds::Union{AbstractDataset,AbstractVariable}) = ()
"""
CommonDatamodel.attrib(ds::Union{AbstractDataset,AbstractVariable},attribname::SymbolOrString)
Return the value of the attribute `attribname` in the data set `ds`.
"""
function attrib(ds::Union{AbstractDataset,AbstractVariable},attribname::SymbolOrString)
error("no attributes $attribname in $(path(ds))")
end
"""
CommonDatamodel.defAttrib(ds::Union{AbstractDataset,AbstractVariable},name::SymbolOrString,data)
Create an attribute with the name `attrib` in the data set or variable `ds`.
"""
function defAttrib(ds::AbstractDataset,name::SymbolOrString,data)
error("unimplemnted for abstract type")
end
"""
CommonDatamodel.delAttrib(ds::Union{AbstractDataset,AbstractVariable},name::SymbolOrString,data)
Deletes an attribute with the name `attrib` in the data set or variable `ds`.
"""
function delAttrib(ds::Union{AbstractDataset,AbstractVariable},name::SymbolOrString,data)
error("unimplemnted for abstract type")
end
attribs(ds::Union{AbstractDataset,AbstractVariable}) =
OrderedDict((dn,attrib(ds,dn)) for dn in attribnames(ds))
#=
CommonDatamodel.show_attrib(io,a)
Print a list all attributes (key/values pairs) in `a` to IO stream `io`.
The IO property `:level` is used for indentation.
=#
function show_attrib(io,a)
level = get(io, :level, 0)
indent = " " ^ level
# need to know ds from a
#if !isopen(ds)
# print(io,"Dataset attributes (file closed)")
# return
#end
try
# use the same order of attributes than in the dataset
for (attname,attval) in a
print(io,indent,@sprintf("%-20s = ",attname))
printstyled(io, @sprintf("%s",attval),color=attribute_color[])
print(io,"\n")
end
catch err
@debug "error while printing" err
print(io,"Dataset attributes (file closed)")
end
end
"""
Base.keys(a::Attributes)
Return a list of the names of all attributes.
"""
Base.keys(a::Attributes) = attribnames(a.ds)
"""
getindex(a::Attributes,name::SymbolOrString)
Return the value of the attribute called `name` from the
attribute list `a`. Generally the attributes are loaded by
indexing, for example:
```julia
using NCDatasets
ds = NCDataset("file.nc")
title = ds.attrib["title"]
```
"""
Base.getindex(a::Attributes,name) = attrib(a.ds,name)
"""
Base.setindex!(a::Attributes,data,name::SymbolOrString)
Set the attribute called `name` to the value `data` in the
attribute list `a`. `data` can be a vector or a scalar. A scalar
is handeld as a vector with one element in the NetCDF data model.
Generally the attributes are defined by indexing, for example:
```julia
ds = NCDataset("file.nc","c")
ds.attrib["title"] = "my title"
close(ds)
```
"""
Base.setindex!(a::Attributes,data,name) = defAttrib(a.ds,name,data)
Base.show(io::IO,a::Attributes) = show_attrib(io,a)
"""
Base.delete!(a::Attributes, name)
Delete the attribute `name` from the attribute list `a`.
"""
Base.delete!(a::Attributes,name::SymbolOrString) = delAttrib(a.ds,name)
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 6119 |
CFStdName(n::AbstractString) = CFStdName(Symbol(n))
macro CF_str(n)
CFStdName(n)
end
import Base.string
Base.string(n::CFStdName) = string(n.name)
"""
ncvar = CommonDataModel.ancillaryvariables(ncv::CFVariable,modifier)
Return the first ancillary variables from the NetCDF (or other format)
variable `ncv` with the
standard name modifier `modifier`. It can be used for example to access
related variable like status flags.
"""
function ancillaryvariables(ncv::CFVariable,modifier)
ds = dataset(ncv)
varname = name(ncv)
if !haskey(ncv.attrib,"ancillary_variables")
return nothing
end
ancillary_variables = split(ncv.attrib["ancillary_variables"])
for ancillary_variable in ancillary_variables
ncv_ancillary = ds[ancillary_variable]
if occursin(modifier,ncv_ancillary.attrib["standard_name"])
@debug ancillary_variable
return ncv_ancillary
end
end
# nothing found
return nothing
end
allowmissing(x::AbstractArray{T}) where {T} = convert(AbstractArray{Union{T, Missing}}, x)
function _filter(ncv::AbstractVariable, indices...; accepted_status_flags = nothing)
data = allowmissing(ncv[indices...])
if (accepted_status_flags != nothing)
ncv_ancillary = ancillaryvariables(ncv,"status_flag");
if ncv_ancillary == nothing
error("no ancillary variable with the attribute status_flag related to $(name(ncv)) found")
end
flag_values = ncv_ancillary.attrib["flag_values"]
flag_meanings = ncv_ancillary.attrib["flag_meanings"]::String
if typeof(flag_meanings) <: AbstractString
flag_meanings = split(flag_meanings)
end
accepted_status_flag_values = zeros(eltype(flag_values),length(accepted_status_flags))
for i = eachindex(accepted_status_flags,accepted_status_flag_values)
tmp = findfirst(accepted_status_flags[i] .== flag_meanings)
if tmp == nothing
error("cannot recognise flag $(accepted_status_flags[i])")
end
accepted_status_flag_values[i] = flag_values[tmp]
end
#@debug accepted_status_flag_values
dataflag = ncv_ancillary.var[indices...];
for i in eachindex(data)
good = false;
for accepted_status_flag_value in accepted_status_flag_values
good = good || (dataflag[i] .== accepted_status_flag_value)
end
if !good
#@show i,dataflag[i]
data[i] = missing
end
end
end
return data
end
"""
data = CommonDataModel.filter(ncv, indices...; accepted_status_flags = nothing)
Load and filter observations by replacing all variables without an acepted status
flag to `missing`. It is used the attribute `ancillary_variables` to identify
the status flag.
```
# da["data"] is 2D matrix
good_data = NCDatasets.filter(ds["data"],:,:, accepted_status_flags = ["good_data","probably_good_data"])
```
"""
filter(ncv::AbstractVariable, indices::TIndices...; kwargs...) =
_filter(ncv, indices...; kwargs...)
filter(ncv::AbstractVariable, indices::Union{Vector{<:Integer}, Array{<:CartesianIndex}}...; kwargs...) =
_filter(ncv, indices...; kwargs...)
filter(ncv::AbstractVariable, indices::BitVector; kwargs...) =
_filter(ncv, indices...; kwargs...)
"""
cv = coord(v::Union{CFVariable,Variable},standard_name)
Find the coordinate of the variable `v` by the standard name `standard_name`
or some [standardized heuristics based on units](https://web.archive.org/web/20190918144052/http://cfconventions.org/cf-conventions/cf-conventions.html#latitude-coordinate). If the heuristics fail to detect the coordinate,
consider to modify the file to add the `standard_name` attribute.
All dimensions of the coordinate must also be dimensions of the variable `v`.
## Example
```julia
using NCDatasets
ds = NCDataset("file.nc")
ncv = ds["SST"]
lon = coord(ncv,"longitude")[:]
lat = coord(ncv,"latitude")[:]
v = ncv[:]
close(ds)
```
"""
function coord(v::AbstractVariable,standard_name)
matches = Dict(
"time" => [r".*since.*"],
# It is great to have choice!
# https://web.archive.org/web/20190918144052/http://cfconventions.org/cf-conventions/cf-conventions.html#latitude-coordinate
"longitude" => [r"degree east",r"degrees east",r"degrees_east",
r"degree_east", r"degree_E", r"degrees_E",
r"degreeE", r"degreesE"],
"latitude" => [r"degree north",r"degrees north",r"degrees_north",
r"degree_north", r"degree_N", r"degrees_N", r"degreeN",
r"degreesN"],
)
ds = dataset(v)
dims = Set(dimnames(v))
# find by standard name
for coord in varbyattrib(ds,standard_name = standard_name)
if Set(dimnames(coord)) ⊆ dims
return coord
end
end
# find by units
if haskey(matches,standard_name)
# prefer e.g. vectors over scalars
# this is necessary for ROMS model output
coordfound = nothing
coordndims = -1
for (_,coord) in ds
units = get(coord.attrib,"units","")
for re in matches[standard_name]
if match(re,units) != nothing
if Set(dimnames(coord)) ⊆ dims
if ndims(coord) > coordndims
coordfound = coord
coordndims = ndims(coord)
end
end
end
end
end
return coordfound
end
return nothing
end
"""
b = bounds(ncvar::NCDatasets.CFVariable)
Return the CFVariable corresponding to the `bounds` attribute of the variable `ncvar`.
The time units and calendar from the `ncvar` are used but not the
attributes controling the
packing of data `scale_factor`, `add_offset` and `_FillValue`.
"""
function bounds(ncvar::CFVariable)
ds = dataset(ncvar)
varname = ncvar.attrib["bounds"]
return ds[varname]
end
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 21292 |
"""
sz = size(var::CFVariable)
Return a tuple of integers with the size of the variable `var`.
!!! note
Note that the size of a variable can change, i.e. for a variable with an
unlimited dimension.
"""
Base.size(v::CFVariable) = size(v.var)
name(v::CFVariable) = name(v.var)
dataset(v::CFVariable) = dataset(v.var)
# be aware that for GRIBDatasets v.attrib is different from v.var.attrib
attribnames(v::CFVariable) = keys(v.attrib)
attrib(v::CFVariable,name::SymbolOrString) = v.attrib[name]
defAttrib(v::CFVariable,name,value) = v.attrib[name] = value
delAttrib(v::CFVariable,name) = delete!(v,name)
dimnames(v::CFVariable) = dimnames(v.var)
dim(v::CFVariable,name::SymbolOrString) = dim(v.var,name)
# necessary for IJulia if showing a variable from a closed file
Base.show(io::IO,::MIME"text/plain",v::AbstractVariable) = show(io,v)
"""
v = cfvariable(ds::NCDataset,varname::SymbolOrString; <attrib> = <value>)
Return the variable `varname` in the dataset `ds` as a
`NCDataset.CFVariable`. The keyword argument `<attrib>` are
the attributes (`fillvalue`, `missing_value`, `scale_factor`, `add_offset`,
`units` and `calendar`) relevant to the CF conventions.
By specifing the value of these attributes, the one can override the value
specified in the data set. If the attribute is set to `nothing`, then
the attribute is not loaded and the corresponding transformation is ignored.
This function is similar to `ds[varname]` with the additional flexibility that
some variable attributes can be overridden.
Example:
```julia
NCDataset("foo.nc","c") do ds
defVar(ds,"data",[10., 11., 12., 13.], ("time",), attrib = Dict(
"add_offset" => 10.,
"scale_factor" => 0.2))
end
# The stored (packed) valued are [0., 5., 10., 15.]
# since 0.2 .* [0., 5., 10., 15.] .+ 10 is [10., 11., 12., 13.]
ds = NCDataset("foo.nc");
@show ds["data"].var[:]
# returns [0., 5., 10., 15.]
@show cfvariable(ds,"data")[:]
# returns [10., 11., 12., 13.]
# neither add_offset nor scale_factor are applied
@show cfvariable(ds,"data", add_offset = nothing, scale_factor = nothing)[:]
# returns [0, 5, 10, 15]
# add_offset is applied but not scale_factor
@show cfvariable(ds,"data", scale_factor = nothing)[:]
# returns [10, 15, 20, 25]
# 0 is declared as the fill value (add_offset and scale_factor are applied as usual)
@show cfvariable(ds,"data", fillvalue = 0)[:]
# returns [missing, 11., 12., 13.]
# Use the time units: days since 2000-01-01
@show cfvariable(ds,"data", units = "days since 2000-01-01")[:]
# returns [DateTime(2000,1,11), DateTime(2000,1,12), DateTime(2000,1,13), DateTime(2000,1,14)]
close(ds)
```
"""
function cfvariable(ds,
varname;
_v = variable(ds,varname),
attrib = _v.attrib,
# special case for bounds variable who inherit
# units and calendar from parent variables
_parentname = boundsParentVar(ds,varname),
fillvalue = get(attrib,"_FillValue",nothing),
# missing_value can be a vector
missing_value = get(attrib,"missing_value",eltype(_v)[]),
#valid_min = get(attrib,"valid_min",nothing),
#valid_max = get(attrib,"valid_max",nothing),
#valid_range = get(attrib,"valid_range",nothing),
scale_factor = get(attrib,"scale_factor",nothing),
add_offset = get(attrib,"add_offset",nothing),
# look also at parent if defined
units = _getattrib(ds,_v,_parentname,"units",nothing),
calendar = _getattrib(ds,_v,_parentname,"calendar",nothing),
maskingvalue = maskingvalue(ds),
)
v = _v
T = eltype(v)
@debug "parent variable" _parentname
# sanity check
if (T <: Number) && (
(eltype(missing_value) <: AbstractChar) ||
(eltype(missing_value) <: AbstractString))
@warn "variable '$varname' has a numeric type but the corresponding " *
"missing_value ($missing_value) is a character or string. " *
"Comparing, e.g. an integer and a string (1 == \"1\") will always evaluate to false. " *
"See the function CommonDataModel.cfvariable how to manually override the missing_value attribute."
end
time_origin = nothing
time_factor = nothing
if (units isa String) && occursin(" since ",units)
if calendar == nothing
calendar = "standard"
elseif calendar isa String
calendar = lowercase(calendar)
end
try
time_origin,time_factor = CFTime.timeunits(units, calendar)
catch err
calendar = nothing
@debug "time units parsing failed " err units calendar
message = (
"cannot parse time units `$units`",
(isnothing(calendar) ? "" : " (calendar `$calendar`)"),
": ",
sprint(showerror,err))
@warn(join(message))
end
end
scaledtype = T
if eltype(v) <: Number
if scale_factor !== nothing
scaledtype = promote_type(scaledtype, typeof(scale_factor))
end
if add_offset !== nothing
scaledtype = promote_type(scaledtype, typeof(add_offset))
end
end
_maskingvalue =
# use NaN32 rather than NaN to avoid unnecessary promotion
# to double precision
if scaledtype == Float32 && maskingvalue === NaN
NaN32
end
_maskingvalue = maskingvalue
storage_attrib = (
fillvalue = fillvalue,
missing_values = (missing_value...,),
scale_factor = scale_factor,
add_offset = add_offset,
calendar = calendar,
time_origin = time_origin,
time_factor = time_factor,
maskingvalue = _maskingvalue,
)
rettype = _get_rettype(ds, calendar, fillvalue, missing_value,
scaledtype,_maskingvalue)
return CFVariable{rettype,ndims(v),typeof(v),typeof(attrib),typeof(storage_attrib)}(
v,attrib,storage_attrib)
end
function _get_rettype(ds, calendar, fillvalue, missing_value, rettype, maskingvalue)
# rettype can be a date if calendar is different from nothing
if calendar !== nothing
DT = nothing
try
DT = CFTime.timetype(calendar)
# this is the only supported option for NCDatasets
prefer_datetime = true
if prefer_datetime &&
(DT in (DateTimeStandard,DateTimeProlepticGregorian,DateTimeJulian))
rettype = DateTime
else
rettype = DT
end
catch
@warn("unsupported calendar `$calendar`. Time units are ignored.")
end
end
if (fillvalue !== nothing) || (!isempty(missing_value))
rettype = promote_type(typeof(maskingvalue),rettype)
end
return rettype
end
fillvalue(v::CFVariable) = v._storage_attrib.fillvalue
missing_values(v::CFVariable) = v._storage_attrib.missing_values
# collect all possible fill values
function fill_and_missing_values(v::CFVariable)
T = eltype(v.var)
fv = ()
if !isnothing(fillvalue(v))
fv = (fillvalue(v),)
end
mv = missing_values(v)
(fv...,mv...)
end
scale_factor(v::CFVariable) = v._storage_attrib.scale_factor
add_offset(v::CFVariable) = v._storage_attrib.add_offset
time_origin(v::CFVariable) = v._storage_attrib.time_origin
calendar(v::CFVariable) = v._storage_attrib.calendar
"""
tf = CommonDataModel.time_factor(v::CFVariable)
The time unit in milliseconds. E.g. seconds would be 1000., days would be 86400000.
The result can also be `nothing` if the variable has no time units.
"""
time_factor(v::CFVariable) = v._storage_attrib.time_factor
maskingvalue(v::CFVariable) = v._storage_attrib.maskingvalue
# fillvalue can be NaN (unfortunately)
@inline isfillvalue(data,fillvalue) = data == fillvalue
@inline isfillvalue(data,fillvalue::AbstractFloat) = (isnan(fillvalue) ? isnan(data) : data == fillvalue)
# tuple peeling
@inline function CFtransform_missing(data,fv::Tuple)
if isfillvalue(data,first(fv))
missing
else
CFtransform_missing(data,Base.tail(fv))
end
end
@inline CFtransform_missing(data,fv::Tuple{}) = data
@inline CFtransform_replace_missing(data,fv) = (ismissing(data) ? first(fv) : data)
@inline CFtransform_replace_missing(data,fv::Tuple{}) = data
@inline CFtransform_scale(data,scale_factor) = data*scale_factor
@inline CFtransform_scale(data,scale_factor::Nothing) = data
@inline CFtransform_scale(data::T,scale_factor) where T <: Union{Char,String} = data
@inline CFtransform_scale(data::T,scale_factor::Nothing) where T <: Union{Char,String} = data
@inline CFtransform_offset(data,add_offset) = data + add_offset
@inline CFtransform_offset(data,add_offset::Nothing) = data
@inline CFtransform_offset(data::T,add_factor) where T <: Union{Char,String} = data
@inline CFtransform_offset(data::T,add_factor::Nothing) where T <: Union{Char,String} = data
@inline asdate(data::Missing,time_origin,time_factor,DTcast) = data
@inline asdate(data,time_origin::Nothing,time_factor,DTcast) = data
@inline asdate(data::Missing,time_origin::Nothing,time_factor,DTcast) = data
@inline asdate(data,time_origin,time_factor,DTcast) =
convert(DTcast,time_origin + Dates.Millisecond(round(Int64,time_factor * data)))
# special case when time variables are stored as single precision,
# promoted internally to double precision
@inline asdate(data::Float32,time_origin::Nothing,time_factor,DTcast) = data
@inline asdate(data::Float32,time_origin,time_factor,DTcast) =
convert(DTcast,time_origin + Dates.Millisecond(round(Int64,time_factor * Float64(data))))
@inline fromdate(data::TimeType,time_origin,inv_time_factor) =
Dates.value(data - time_origin) * inv_time_factor
@inline fromdate(data,time_origin,time_factor) = data
@inline CFtransformmaskingvalue(data,maskingvalue) = data
@inline CFtransformmaskingvalue(data::Missing,maskingvalue) = maskingvalue
@inline CFinvtransformmaskingvalue(data,maskingvalue::Missing) = data
# fall-back if maskingvalue is not missing
# for numbers we use == (rather ===) so that 40 == 40. is true
# but we need to double check for NaNs
@inline function CFinvtransformmaskingvalue(data::Number,maskingvalue::Number)
if (data == maskingvalue) || (isnan(maskingvalue) && isnan(data))
return missing
else
data
end
end
# if maskingvalue is not a number e.g. nothing, isnan is not defined
@inline function CFinvtransformmaskingvalue(data,maskingvalue)
if data === maskingvalue
return missing
else
data
end
end
# Transformation pipelne
#
# fillvalue to missing -> scale -> add offset -> transform to dates -> missing to maskingvalue (alternative sentinel value)
#
# Inverse transformation pipleine
#
# maskingvalue to missing -> round float if should be ints -> encode dates -> remove offset -> inverse scalling -> missing to fillvalue
#
# All steps are optional and can be skipped if not applicable
@inline function CFtransform(data,fv,scale_factor,add_offset,time_origin,time_factor,maskingvalue,DTcast)
return CFtransformmaskingvalue(
asdate(
CFtransform_offset(
CFtransform_scale(
CFtransform_missing(
data,fv),
scale_factor),
add_offset),
time_origin,time_factor,DTcast),
maskingvalue)
end
# round float to integers
_approximate(::Type{T},data) where T <: Integer = round(T,data)
_approximate(::Type,data) = data
@inline function CFinvtransform(data,fv,inv_scale_factor,minus_offset,time_origin,inv_time_factor,maskingvalue,DT)
return _approximate(
DT,
CFtransform_replace_missing(
CFtransform_scale(
CFtransform_offset(
fromdate(
CFinvtransformmaskingvalue(
data,maskingvalue),
time_origin,inv_time_factor),
minus_offset),
inv_scale_factor),
fv))
end
# this is really slow
# https://github.com/JuliaLang/julia/issues/28126
#@inline CFtransformdata(data,fv,scale_factor,add_offset,time_origin,time_factor,DTcast) =
# # in boardcasting we trust..., or not
# CFtransform.(data,fv,scale_factor,add_offset,time_origin,time_factor,DTcast)
# for scalars
@inline CFtransformdata(data,fv,scale_factor,add_offset,time_origin,time_factor,maskingvalue,DTcast) =
CFtransform(data,fv,scale_factor,add_offset,time_origin,time_factor,maskingvalue,DTcast)
# in-place version
@inline function CFtransformdata!(out,data::AbstractArray{T,N},fv,scale_factor,add_offset,time_origin,time_factor,maskingvalue) where {T,N}
DTcast = eltype(out)
@inbounds @simd for i in eachindex(data)
out[i] = CFtransform(data[i],fv,scale_factor,add_offset,time_origin,time_factor,maskingvalue,DTcast)
end
return out
end
# for arrays
@inline function CFtransformdata(data::AbstractArray{T,N},fv,scale_factor,add_offset,time_origin,time_factor,maskingvalue,DTcast) where {T,N}
out = Array{DTcast,N}(undef,size(data))
return CFtransformdata!(out,data::AbstractArray{T,N},fv,scale_factor,add_offset,time_origin,time_factor,maskingvalue)
end
@inline function CFtransformdata(
data::AbstractArray{T,N},fv::Tuple{},scale_factor::Nothing,
add_offset::Nothing,time_origin::Nothing,time_factor::Nothing,maskingvalue,::Type{T}) where {T,N}
# no transformation necessary (avoid allocation)
return data
end
@inline _inv(x::Nothing) = nothing
@inline _inv(x) = 1/x
@inline _minus(x::Nothing) = nothing
@inline _minus(x) = -x
# # so slow
# @inline function CFinvtransformdata(data,fv,scale_factor,add_offset,time_origin,time_factor,DT)
# inv_scale_factor = _inv(scale_factor)
# minus_offset = _minus(add_offset)
# inv_time_factor = _inv(time_factor)
# return CFinvtransform.(data,fv,inv_scale_factor,minus_offset,time_origin,inv_time_factor,DT)
# end
# for arrays
@inline function CFinvtransformdata(data::AbstractArray{T,N},fv,scale_factor,add_offset,time_origin,time_factor,maskingvalue,DT) where {T,N}
inv_scale_factor = _inv(scale_factor)
minus_offset = _minus(add_offset)
inv_time_factor = _inv(time_factor)
out = Array{DT,N}(undef,size(data))
@inbounds @simd for i in eachindex(data)
out[i] = CFinvtransform(data[i],fv,inv_scale_factor,minus_offset,time_origin,inv_time_factor,maskingvalue,DT)
end
return out
end
@inline function CFinvtransformdata(
data::AbstractArray{T,N},fv::Tuple{},scale_factor::Nothing,
add_offset::Nothing,time_origin::Nothing,time_factor::Nothing,maskingvalue,::Type{T}) where {T,N}
# no transformation necessary (avoid allocation)
return data
end
# for scalar
@inline function CFinvtransformdata(data,fv,scale_factor,add_offset,time_origin,time_factor,maskingvalue,DT)
inv_scale_factor = _inv(scale_factor)
minus_offset = _minus(add_offset)
inv_time_factor = _inv(time_factor)
return CFinvtransform(data,fv,inv_scale_factor,minus_offset,time_origin,inv_time_factor,maskingvalue,DT)
end
# this function is necessary to avoid "iterating" over a single character in Julia 1.0 (fixed Julia 1.3)
# https://discourse.julialang.org/t/broadcasting-and-single-characters/16836
#@inline CFtransformdata(data::Char,fv,scale_factor,add_offset,time_origin,time_factor,DTcast) = CFtransform_missing(data,fv)
#@inline CFinvtransformdata(data::Char,fv,scale_factor,add_offset,time_origin,time_factor,DT) = CFtransform_replace_missing(data,fv)
function Base.getindex(v::CFVariable, indexes::TIndices...)
data = v.var[indexes...]
return CFtransformdata(data,fill_and_missing_values(v),scale_factor(v),add_offset(v),
time_origin(v),time_factor(v),maskingvalue(v),eltype(v))
end
function Base.setindex!(v::CFVariable,data::Array{Missing,N},indexes::TIndices...) where N
v.var[indexes...] = fill(fillvalue(v),size(data))
end
function Base.setindex!(v::CFVariable,data::Missing,indexes::TIndices...)
v.var[indexes...] = fillvalue(v)
end
function Base.setindex!(v::CFVariable,data::Union{T,Array{T}},indexes::TIndices...) where T <: Union{AbstractCFDateTime,DateTime,Missing}
if calendar(v) !== nothing
# can throw an convertion error if calendar attribute already exists and
# is incompatible with the provided data
v.var[indexes...] = CFinvtransformdata(
data,fill_and_missing_values(v),scale_factor(v),add_offset(v),
time_origin(v),time_factor(v),
maskingvalue(v),
eltype(v.var))
return data
end
@error "Time units and calendar must be defined during defVar and cannot change"
end
function Base.setindex!(v::CFVariable,data,indexes::TIndices...)
v.var[indexes...] = CFinvtransformdata(
data,fill_and_missing_values(v),
scale_factor(v),add_offset(v),
time_origin(v),time_factor(v),
maskingvalue(v),
eltype(v.var))
return data
end
# can be implemented overridden for faster implementation
function boundsParentVar(ds,varname)
for vn in varnames(ds)
v = variable(ds,vn)
bounds = get(attribs(v),"bounds","")
if bounds === varname
return vn
end
end
return ""
end
#=
_getattrib(ds,v,parentname,attribname,default)
Get an attribute, looking also at the parent variable name
(linked via the bounds attribute as following the CF conventions).
The default value is returned if the attribute cannot be found.
=#
function _getattrib(ds,v,parentname,attribname,default)
val = get(v.attrib,attribname,nothing)
if val !== nothing
return val
else
if (parentname === nothing) || (parentname === "")
return default
else
vp = variable(ds,parentname)
return get(vp.attrib,attribname,default)
end
end
end
function _isrelated(v1::AbstractVariable,v2::AbstractVariable)
dimnames(v1) ⊆ dimnames(v2)
end
function Base.keys(v::AbstractVariable)
ds = dataset(v)
return [varname for (varname,ncvar) in ds if _isrelated(ncvar,v)]
end
function Base.getindex(v::AbstractVariable,name::SymbolOrString)
ds = dataset(v)
ncvar = ds[name]
if _isrelated(ncvar,v)
return ncvar
else
throw(KeyError(name))
end
end
"""
dimnames(v::CFVariable)
Return a tuple of strings with the dimension names of the variable `v`.
"""
dimnames(v::Union{CFVariable,MFCFVariable}) = dimnames(v.var)
name(v::Union{CFVariable,MFCFVariable}) = name(v.var)
chunking(v::CFVariable,storage,chunksize) = chunking(v.var,storage,chunksize)
chunking(v::CFVariable) = chunking(v.var)
deflate(v::CFVariable,shuffle,dodeflate,deflate_level) = deflate(v.var,shuffle,dodeflate,deflate_level)
deflate(v::CFVariable) = deflate(v.var)
checksum(v::CFVariable,checksummethod) = checksum(v.var,checksummethod)
checksum(v::CFVariable) = checksum(v.var)
fillmode(v::CFVariable) = fillmode(v.var)
############################################################
# Convertion to array
############################################################
Base.Array(v::AbstractVariable{T,N}) where {T,N} = v[ntuple(i -> :, Val(N))...]
function Base.Array(v::AbstractVariable{T,0}) where {T}
a = Array{T,0}(undef,size(v))
# only a single element to load
a[] = v[]
return a
end
"""
CommonDataModel.load!(ncvar::CFVariable, data, buffer, indices)
Loads a NetCDF (or other format) variables `ncvar` in-place and puts the result in `data` (an
array of `eltype(ncvar)`) along the specified `indices`. `buffer` is a temporary
array of the same size as data but the type should be `eltype(ncv.var)`, i.e.
the corresponding type in the files (before applying `scale_factor`,
`add_offset` and masking fill values). Scaling and masking will be applied to
the array `data`.
`data` and `buffer` can be the same array if `eltype(ncvar) == eltype(ncvar.var)`.
## Example:
```julia
# create some test array
Dataset("file.nc","c") do ds
defDim(ds,"time",3)
ncvar = defVar(ds,"vgos",Int16,("time",),attrib = ["scale_factor" => 0.1])
ncvar[:] = [1.1, 1.2, 1.3]
# store 11, 12 and 13 as scale_factor is 0.1
end
ds = Dataset("file.nc")
ncv = ds["vgos"];
# data and buffer must have the right shape and type
data = zeros(eltype(ncv),size(ncv)); # here Vector{Float64}
buffer = zeros(eltype(ncv.var),size(ncv)); # here Vector{Int16}
NCDatasets.load!(ncv,data,buffer,:,:,:)
close(ds)
```
"""
@inline function load!(v::Union{CFVariable{T,N},MFCFVariable{T,N},SubVariable{T,N}}, data, buffer, indices::TIndices...) where {T,N}
if v.var == nothing
return load!(v,indices...)
else
load!(v.var,buffer,indices...)
fmv = fill_and_missing_values(v)
return CFtransformdata!(data,buffer,fmv,scale_factor(v),add_offset(v),
time_origin(v),time_factor(v),
maskingvalue(v))
end
end
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 11373 |
"""
CommonDatamodel.path(ds::AbstractDataset)
File path of the data set `ds`.
"""
path(ds::AbstractDataset) = ""
Base.close(ds::AbstractDataset) = nothing
"""
CommonDatamodel.name(ds::AbstractDataset)
Name of the group of the data set `ds`. For a data set containing
only a single group, this will be always the root group `"/"`.
"""
name(ds::AbstractDataset) = "/"
"""
pds = CommonDatamodel.parentdataset(ds::AbstractDataset)
The data set `pds` containing `ds` as a sub-group.
`pds` is nothing for the root group.
"""
parentdataset(ds::AbstractDataset) = nothing
sync(ds::AbstractDataset) = nothing
"""
CommonDatamodel.groupnames(ds::AbstractDataset)
All the subgroup names of the data set `ds`. For a data set containing
only a single group, this will be an empty vector of `String`.
"""
groupnames(ds::AbstractDataset) = ()
"""
CommonDatamodel.group(ds::AbstractDataset,groupname::SymbolOrString)
Return the sub-group data set with the name `groupname`.
"""
function group(ds::AbstractDataset,groupname::SymbolOrString)
error("no group $groupname in $(path(ds))")
end
"""
group = CommonDatamodel.defGroup(ds::AbstractDataset,name::SymbolOrString)
Create an empty sub-group with the name `name` in the data set `ds`.
The `group` is a sub-type of `AbstractDataset`.
"""
function defGroup(ds::AbstractDataset,name::SymbolOrString)
error("unimplemented for abstract type")
end
"""
CommonDatamodel.groups(ds::AbstractDataset)
Return all sub-group data as a dict-like object.
"""
groups(ds::AbstractDataset) =
OrderedDict((dn,group(ds,dn)) for dn in groupnames(ds))
"""
CommonDatamodel.unlimited(ds::AbstractDataset)
Iterator of strings with the name of the unlimited dimension.
"""
unlimited(ad::AbstractDataset) = ()
Base.isopen(ds::AbstractDataset) = true
function Base.show(io::IO,ds::AbstractDataset)
level = get(io, :level, 0)
indent = " " ^ level
if !isopen(ds)
print(io,"closed Dataset")
return
end
dspath = path(ds)
printstyled(io, indent, "Dataset: ",dspath,"\n", color=section_color[])
print(io,indent,"Group: ",name(ds),"\n")
print(io,"\n")
# show dimensions
if length(dimnames(ds)) > 0
show_dim(io, dims(ds))
print(io,"\n")
end
varnames = keys(ds)
if length(varnames) > 0
printstyled(io, indent, "Variables\n",color=section_color[])
for name in varnames
show(IOContext(io,:level=>level+2),ds[name])
print(io,"\n")
end
end
# global attribues
if length(attribnames(ds)) > 0
printstyled(io, indent, "Global attributes\n",color=section_color[])
show_attrib(IOContext(io,:level=>level+2),attribs(ds));
end
# groups
gnames = groupnames(ds)
if length(gnames) > 0
printstyled(io, indent, "Groups\n",color=section_color[])
for groupname in gnames
show(IOContext(io,:level=>level+2),group(ds,groupname))
end
end
end
maskingvalue(ds::AbstractDataset) = missing
"""
v = getindex(ds::AbstractDataset, varname::SymbolOrString)
Return the variable `varname` in the dataset `ds` as a
`CFVariable`. The following CF convention are honored when the
variable is indexed:
* `_FillValue` or `missing_value` (which can be a list) will be returned as `missing`.
* `scale_factor` and `add_offset` are applied (output = `scale_factor` * `data_in_file` + `add_offset`)
* time variables (recognized by the units attribute and possibly the calendar attribute) are returned usually as
`DateTime` object. Note that `CFTime.DateTimeAllLeap`, `CFTime.DateTimeNoLeap` and
`CF.TimeDateTime360Day` cannot be converted to the proleptic gregorian calendar used in
julia and are returned as such. (See [`CFTime.jl`](https://github.com/JuliaGeo/CFTime.jl)
for more information about those date types.) If a calendar is defined but not among the
ones specified in the CF convention, then the data in the file is not
converted into a date structure.
A call `getindex(ds, varname)` is usually written as `ds[varname]`.
If variable represents a cell boundary, the attributes `calendar` and `units` of the related variables are used, if they are not specified. For example:
```
dimensions:
time = UNLIMITED; // (5 currently)
nv = 2;
variables:
double time(time);
time:long_name = "time";
time:units = "hours since 1998-04-019 06:00:00";
time:bounds = "time_bnds";
double time_bnds(time,nv);
```
In this case, the variable `time_bnds` uses the units and calendar of `time`
because both variables are related thought the bounds attribute following the CF conventions.
See also [`cfvariable(ds, varname)`](@ref).
"""
function Base.getindex(ds::AbstractDataset,varname::SymbolOrString)
return cfvariable(ds, varname)
end
function Base.setindex!(ds::AbstractDataset,data::AbstractVariable,varname::SymbolOrString)
return defVar(ds, varname, data)
end
function Base.haskey(ds::AbstractDataset,varname)
return Symbol(varname) in Symbol.(keys(ds))
end
"""
varbyattrib(ds, attname = attval)
Returns a list of variable(s) which has the attribute `attname` matching the value `attval`
in the dataset `ds`.
The list is empty if the none of the variables has the match.
The output is a list of `CFVariable`s.
# Examples
Load all the data of the first variable with standard name "longitude" from the
NetCDF file `results.nc`.
```julia-repl
julia> ds = NCDataset("results.nc", "r");
julia> data = varbyattrib(ds, standard_name = "longitude")[1][:]
```
"""
function varbyattrib(ds::Union{AbstractDataset,AbstractVariable}; kwargs...)
# Start with an empty list of variables
varlist = []
# Loop on the variables
for v in keys(ds)
var = ds[v]
matchall = true
for (attsym,attval) in kwargs
attname = String(attsym)
# Check if the variable has the desired attribute
if attname in attribnames(var)
# Check if the attribute value is the selected one
if attrib(var,attname) != attval
matchall = false
break
end
else
matchall = false
break
end
end
if matchall
push!(varlist, var)
end
end
return varlist
end
"""
var = getindex(ds::Union{AbstractDataset,AbstractVariable},cfname::CFStdName)
Return the NetCDF variable `var` with the standard name `cfname` from a
dataset. If the first argument is a variable, then the search is limited to
all variables with the same dimension names.
"""
function Base.getindex(ds::Union{AbstractDataset,AbstractVariable},n::CFStdName)
ncvars = varbyattrib(ds, standard_name = String(n.name))
if length(ncvars) == 1
return ncvars[1]
else
throw(KeyError("$(length(ncvars)) matches while searching for a variable with standard_name attribute equal to $(n.name)"))
end
end
"""
names = keys(g::Groups)
Return the names of all subgroubs of the group `g`.
"""
Base.keys(groups::Groups) = groupnames(groups.ds)
"""
group = getindex(g::Groups,groupname::AbstractString)
Return the NetCDF `group` with the name `groupname` from the parent
group `g`.
For example:
```julia
ds = NCDataset("results.nc", "r");
forecast_group = ds.group["forecast"]
forecast_temp = forecast_group["temperature"]
```
"""
Base.getindex(groups::Groups,name) = group(groups.ds,name)
# Initialize the ds._boundsmap variable
function initboundsmap!(ds)
empty!(ds._boundsmap)
for vname in keys(ds)
v = variable(ds,vname)
bounds = get(v.attrib,"bounds",nothing)
if bounds !== nothing
ds._boundsmap[bounds] = vname
end
end
end
"""
write(dest::AbstractDataset, src::AbstractDataset; include = keys(src), exclude = [])
Write the variables of `src` dataset into an empty `dest` dataset (which must be opened in mode `"a"` or `"c"`).
The keywords `include` and `exclude` configure which variable of `src` should be included
(by default all), or which should be `excluded` (by default none).
If the first argument is a file name, then the dataset is open in create mode (`"c"`).
This function is useful when you want to save the dataset from a multi-file dataset.
To save a subset, one can use the view function `view` to virtually slice
a dataset:
## Example
```
NCDataset(fname_src) do ds
write(fname_slice,view(ds, lon = 2:3))
end
```
All variables in the source file `fname_src` with a dimension `lon` will be sliced
along the indices `2:3` for the `lon` dimension. All attributes (and variables
without a dimension `lon`) will be copied over unmodified.
"""
function Base.write(dest::AbstractDataset, src::AbstractDataset;
include = keys(src),
exclude = String[],
_ignore_checksum = false,
)
unlimited_dims = unlimited(src)
for (dimname,dimlength) in dims(src)
isunlimited = dimname in unlimited_dims
# if haskey(dest.dim,dimname)
# # check length
# if (dest.dim[dimname] !== src.dim[dimname]) && !isunlimited
# throw(DimensionMismatch("length of the dimensions $dimname are inconstitent in files $(path(dest)) and $(path(src))"))
# end
# else
if isunlimited
defDim(dest, dimname, Inf)
else
defDim(dest, dimname, dimlength)
end
# end
end
# loop over variables
for varname in include
(varname ∈ exclude) && continue
@debug "Writing variable $varname..."
kwargs =
if _ignore_checksum
(checksum = nothing,)
else
()
end
defVar(dest,src[varname]; kwargs...)
end
# loop over all global attributes
for (attribname,attribval) in attribs(src)
dest.attrib[attribname] = attribval
end
# loop over all groups
for (groupname,groupsrc) in groups(src)
groupdest = defGroup(dest,groupname)
write(groupdest,groupsrc)
end
return dest
end
@inline function Base.getproperty(ds::Union{AbstractDataset,AbstractVariable},name::Symbol)
if (name == :attrib) && !hasfield(typeof(ds),name)
return Attributes(ds)
elseif (name == :dim) && !hasfield(typeof(ds),name)
return Dimensions(ds)
elseif (name == :group) && !hasfield(typeof(ds),name) && (ds isa AbstractDataset)
return Groups(ds)
else
return getfield(ds,name)
end
end
for (item_color,default) in (
(:section_color, :red),
(:attribute_color, :cyan),
(:variable_color, :green),
)
item_color_str = String(item_color)
item_str = split(item_color_str,"_")[1]
default_str = String(default)
@eval begin
$item_color = Ref(Symbol(load_preference(CommonDataModel,$(item_color_str), $(QuoteNode(default)))))
"""
CommonDataModel.set_$($item_color_str)(color::Symbol)
Set the $($item_str) color. The default color is `$($default_str)`.
"""
function $(Symbol(:set_,item_color))(color::Symbol)
@set_preferences!($(item_color_str) => String(color))
$item_color[] = color
end
end
end
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 4651 | iswritable(dds::DeferDataset) = dds.r.mode != "r"
function metadata(ds::AbstractDataset)
# dimensions
dim = OrderedDict()
unlimited_dims = unlimited(ds.dim)
for (dimname,dimlen) in ds.dim
dim[dimname] = Dict(
:name => dimname,
:length => dimlen,
:unlimited => dimname in unlimited_dims
)
end
# variables
vars = OrderedDict()
for (varname,ncvar) in ds
storage,chunksizes = chunking(ncvar.var)
isshuffled,isdeflated,deflatelevel = deflate(ncvar.var)
checksummethod = checksum(ncvar.var)
vars[varname] = OrderedDict(
:name => varname,
:size => size(ncvar),
:eltype => eltype(ncvar.var),
:attrib => OrderedDict(ncvar.attrib),
:dimensions => dimnames(ncvar),
:chunksize => chunksizes,
:storage => storage,
#:fillvalue => fillvalue(ncvar.var),
:shuffle => isshuffled,
:deflate => isdeflated,
:deflatelevel => deflatelevel,
:checksummethod => checksummethod,
)
end
group = OrderedDict()
for (groupname,ncgroup) in ds.group
group[groupname] = metadata(ncgroup)
end
return OrderedDict(
:dim => dim,
:var => vars,
:attrib => OrderedDict(ds.attrib),
:group => group
)
end
function DeferDataset(TDS,r::Resource,groupname::String,data::OrderedDict)
_boundsmap = Dict{String,String}()
dds = DeferDataset{TDS}(r,groupname,data,_boundsmap)
if (r.mode == "r")
initboundsmap!(dds)
end
return dds
end
function DeferDataset(TDS,filename::AbstractString,mode::AbstractString,info::OrderedDict)
TDS(filename,mode) do ds
r = Resource(filename,mode,info)
groupname = "/"
return DeferDataset(TDS,r,groupname,info)
end
end
function DeferDataset(TDS,filename::AbstractString,mode = "r")
TDS(filename,mode) do ds
info = metadata(ds)
r = Resource(filename,mode,info)
groupname = "/"
return DeferDataset(TDS,r,groupname,info)
end
end
# files are not suppose to be open where using DeferDataset
close(dds::DeferDataset) = nothing
groupname(dds::DeferDataset) = dds.groupname
path(dds::DeferDataset) = dds.r.filename
Base.keys(dds::DeferDataset) = collect(keys(dds.data[:var]))
function Variable(f::Function, dv::DeferVariable{T,N,TDS}) where {T,N,TDS}
TDS(dv.r.filename,dv.r.mode) do ds
f(variable(ds,dv.varname))
end
end
function variable(dds::DeferDataset{TDS},varname::AbstractString) where TDS
data = get(dds.data[:var],varname,nothing)
if data == nothing
error("Dataset $(dds.r.filename) does not contain the variable $varname")
end
T = data[:eltype]
N = length(data[:dimensions])
return DeferVariable{T,N,TDS}(dds.r,varname,data)
end
variable(dds::DeferDataset,varname::Symbol) = variable(dds,string(varname))
dataset(dv::DeferVariable{T,N,TDS}) where {T,N,TDS} =
DeferDataset(TDS,dv.r.filename,dv.r.mode)
function Base.getindex(dv::DeferVariable,indexes::Union{Int,Colon,AbstractRange{<:Integer}}...)
Variable(dv) do v
return v[indexes...]
end
end
Base.size(dv::DeferVariable) = dv.data[:size]
dimnames(dv::DeferVariable) = dv.data[:dimensions]
name(dv::DeferVariable) = dv.varname
#----------------------------------------------
dimnames(dds::DeferDataset) = collect(keys(dds.r.metadata[:dim]))
dim(dds::DeferDataset,name::SymbolOrString) =
dds.r.metadata[:dim][String(name)][:length]
unlimited(dd::DeferDataset) = [dimname for (dimname,dim) in dd.data[:dim] if dim[:unlimited]]
attribnames(dds::DeferDataset) = collect(keys(dds.r.metadata[:attrib]))
attrib(dds::DeferDataset,name::SymbolOrString) = dds.r.metadata[:attrib][String(name)]
attribnames(dv::DeferVariable) = collect(keys(dv.data[:attrib]))
attrib(dv::DeferVariable,name::SymbolOrString) = dv.data[:attrib][String(name)]
#------------------------------------------------
groupnames(dds::DeferDataset) = collect(keys(dds.data[:group]))
function group(dds::DeferDataset{TDS},name::SymbolOrString) where TDS
data = dds.data[:group][String(name)]
return DeferDataset(TDS,dds.r,String(name),data)
end
_storage_attributes(dv) = dv.r.metadata[:var][name(dv)]
function chunking(dv::DeferVariable)
sa = _storage_attributes(dv)
return sa[:storage],sa[:chunksize]
end
function deflate(dv::DeferVariable)
sa = _storage_attributes(dv)
return sa[:shuffle],sa[:deflate],sa[:deflatelevel]
end
checksum(dv::DeferVariable) = _storage_attributes(dv)[:checksummethod]
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 3475 |
"""
CommonDatamodel.dimnames(ds::AbstractDataset)
Return an iterable of all dimension names in `ds`. This
information can also be accessed using the property `ds.dim`:
# Examples
```julia
ds = NCDataset("results.nc", "r");
dimnames = keys(ds.dim)
```
"""
dimnames(ds::Union{AbstractDataset,AbstractVariable}) = ()
function _dimnames_recursive(ds::AbstractDataset)
dn = collect(dimnames(ds))
pd = parentdataset(ds)
if pd !== nothing
append!(dn,_dimnames_recursive(pd))
end
return Tuple(dn)
end
"""
CommonDatamodel.dim(ds::AbstractDataset,dimname::SymbolOrString)
Return the length of the dimension `dimname` in the data set `ds`.
"""
function dim(v::AbstractVariable,dimname::SymbolOrString)
if !(String(dimname) in dimnames(v))
error("$dimname is not among the dimensions of $(name(v))")
end
return dim(dataset(v),dimname)
end
function dim(ds::AbstractDataset,dimname::SymbolOrString)
error("no dimension $dimname in $(path(ds))")
end
"""
CommonDatamodel.defDim(ds::AbstractDataset,name::SymbolOrString,len)
Create dimension with the name `name` in the data set `ds` with the length `len`.
`len` can be `Inf` for unlimited dimensions.
"""
function defDim(ds::AbstractDataset,name::SymbolOrString,len)
error("unimplemnted for abstract type")
end
"""
CommonDatamodel.dims(ds::Union{AbstractDataset,AbstractVariable})
Return a dict-like of all dimensions and their corresponding length defined in the the data set `ds` (or variable).
"""
dims(ds::Union{AbstractDataset,AbstractVariable}) =
OrderedDict((dn,dim(ds,dn)) for dn in dimnames(ds))
"""
CommonDatamodel.show_dim(io,dim)
Print a list all dimensions (key/values pairs where key is the dimension names
and value the corresponding length) in `dim` to IO stream `io`.
The IO property `:level` is used for indentation.
"""
function show_dim(io::IO, d)
level = get(io, :level, 0)
indent = " " ^ level
printstyled(io, indent, "Dimensions\n",color=section_color[])
try
for (dimname,dimlen) in d
print(io,indent," $(dimname) = $(dimlen)\n")
end
catch err
print(io, "Dimensions (file closed)")
end
end
"""
keys(d::Dimensions)
Return a list of all dimension names in NCDataset `ds`.
# Examples
```julia
ds = NCDataset("results.nc", "r");
dimnames = keys(ds.dim)
```
"""
Base.keys(dims::Dimensions) = dimnames(dims.ds)
Base.getindex(dims::Dimensions,name) = dim(dims.ds,name)
"""
setindex!(d::Dimensions,len,name::AbstractString)
Defines the dimension called `name` to the length `len`, for example:
```julia
ds = NCDataset("file.nc","c")
ds.dim["longitude"] = 100
```
If `len` is the special value `Inf`, then the dimension is considered as
`unlimited`, i.e. it will grow as data is added to the NetCDF file.
"""
Base.setindex!(dims::Dimensions,data,name) = defDim(dims.ds,name,data)
Base.show(io::IO,dims::Dimensions) = show_dim(io,dims)
"""
unlimited(d::Dimensions)
Return the names of all unlimited dimensions.
"""
unlimited(dims::Dimensions) = unlimited(dims.ds)
Base.length(a::Iterable) = length(keys(a))
function Base.iterate(a::Iterable, state = collect(keys(a)))
if length(state) == 0
return nothing
end
return (state[1] => a[popfirst!(state)], state)
end
function Base.get(a::Iterable, name::SymbolOrString, default)
if haskey(a,name)
return a[name]
else
return default
end
end
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 18938 | #
# types
#
# mappings between groups and source data
abstract type AbstractGroupMapping; end
# non-overlapping groups
struct GroupMapping{TClass,TUC} <: AbstractGroupMapping where {TClass <: AbstractVector{T}, TUC <: Union{T,AbstractVector{T}}} where T
class::TClass
unique_class::TUC
end
struct GroupedDataset{TDS<:AbstractDataset,TF,TGM,TM}
ds::TDS # dataset
coordname::Symbol
group_fun::TF # mapping function
groupmap::TGM
map_fun::TM
end
struct ReducedGroupedDataset{TDS,TF,TGM,TM,TRF} <: AbstractDataset
ds::TDS # dataset
coordname::Symbol
group_fun::TF # mapping function
groupmap::TGM
map_fun::TM
reduce_fun::TRF
end
struct GroupedVariable{TV,TF,TGM,TM,TG} <: AbstractVector{TG} where TV <: AbstractArray{T,N} where {T,N}
v::TV # dataset
coordname::Symbol
# mapping function to create groups when applied to coordinate
group_fun::TF
groupmap::TGM
dim::Int
map_fun::TM
end
# reduce_fun is e.g. sum, mean, var,...
# map_fun is the mapping function applied before reduction
struct ReducedGroupedVariable{T,N,TGV,TF} <: AbstractVariable{T,N}
gv::TGV
reduce_fun::TF
_attrib::OrderedDict{String,Any}
end
function dataindices(gmap::GroupMapping,ku)
class_ku = gmap.unique_class[ku]
return findall(==(class_ku),gmap.class)
end
function groupindices(gmap::GroupMapping,k)
# Types like Dates.Month behave different than normal scalars, e.g.
# julia> length(Dates.Month(1))
# ERROR: MethodError: no method matching length(::Month)
if gmap.unique_class isa DatePeriod
if gmap.unique_class == gmap.class[k]
return (1,)
else
return ()
end
end
for ku = 1:length(gmap.unique_class)
if gmap.unique_class[ku] == gmap.class[k]
return (ku,)
end
end
return ()
end
grouplabel(gmap::GroupMapping,ku) = gmap.unique_class[ku]
# Types like Dates.Month behave different than normal scalars, e.g.
# julia> length(Dates.Month(1))
# ERROR: MethodError: no method matching length(::Month)
_length(x) = length(x)
_length(x::DatePeriod) = 1
ngroups(gmap::GroupMapping) = _length(gmap.unique_class)
ndata(gmap::GroupMapping) = length(gmap.class)
function groupsubset(gmap::GroupMapping,kus)
return GroupMapping(gmap.class,gmap.unique_class[kus])
end
groupsubset(gmap::GroupMapping,kus::Colon) = gmap
#--------------
# helper function
_indices_helper(j,ku,i,val) = ()
_indices_helper(j,ku,i,val,ind1::Integer,indices...) = _indices_helper(j,ku,i+1,val,indices...)
_indices_helper(j,ku,i,val,ind1,indices...) = ((i == j ? ku : val), _indices_helper(j,ku,i+1,val,indices...)...)
# _indices(j,ku,val,indices) produces a tuple with val for every dimension
# except `ku` for the the `j` dimension for an array A after subsetting it as
# `A[indices]`.
_indices(j,ku,val,indices) = _indices_helper(j,ku,1,val,indices...)
_dest_indices(j,ku,indices) = _indices_helper(j,ku,1,:,indices...)
@inline size_getindex(array,indexes...) = _size_getindex(array,(),1,indexes...)
@inline _size_getindex(array,sh,n,i::Integer,indexes...) = _size_getindex(array,sh, n+1,indexes...)
@inline _size_getindex(array::AbstractArray,sh,n,i::Colon, indexes...) = _size_getindex(array,(sh...,size(array,n)),n+1,indexes...)
@inline _size_getindex(sz::Tuple,sh,n,i::Colon, indexes...) = _size_getindex(sz,(sh...,sz[n]),n+1,indexes...)
@inline _size_getindex(array,sh,n,i, indexes...) = _size_getindex(array,(sh...,length(i)), n+1,indexes...)
@inline _size_getindex(array,sh,n) = sh
#
# methods with ReducedGroupedDataset as main argument
#
Base.keys(gds::ReducedGroupedDataset) = keys(gds.ds)
function variable(gds::ReducedGroupedDataset,varname::SymbolOrString)
v = variable(gds.ds,varname)
dim = findfirst(==(gds.coordname),Symbol.(dimnames(v)))
if isnothing(dim)
return v
else
gv = GroupedVariable(
v,
gds.coordname,
gds.group_fun,
gds.groupmap,
dim,
gds.map_fun)
return ReducedGroupedVariable(gv,gds.reduce_fun)
end
end
attribnames(gds::ReducedGroupedDataset) = attribnames(gds.ds)
attrib(gds::ReducedGroupedDataset,attribname::SymbolOrString) =
attrib(gds.ds,attribname)
#
# methods with GroupedVariable as main argument
#
function Base.show(io::IO,::MIME"text/plain",gv::GroupedVariable)
println(io,length(gv),"-element ",
"variable grouped by '",gv.coordname,"'",
" of array '",name(gv.v),"' ",
join(string.(size(gv.v)),"×"),
" (",
join(dimnames(gv.v),"×"),
")",
)
end
Base.show(io::IO,gv::GroupedVariable) = Base.show(io,MIME"text/plain",gv)
Base.ndims(gv::GroupedVariable) = 1
Base.size(gv::GroupedVariable) = (ngroups(gv.groupmap),)
Base.eltype(gv::GroupedVariable{TV,TF,TGM,TM,TG}) where {TV,TF,TGM,TM,TG} = TG
function Base.getindex(gv::GroupedVariable,k::Integer)
class_k,indices = group(gv,k)
return gv.map_fun(Array(selectdim(gv.v,gv.dim,indices)))
end
function group(gv::GroupedVariable,ku::Integer)
# make generic
class_ku = grouplabel(gv.groupmap,ku)
k = dataindices(gv.groupmap,ku)
return class_ku, k
end
function _mapreduce(map_fun,reduce_op,gv::GroupedVariable{TV},indices;
init = reduce(reduce_op,T[])) where TV <: AbstractArray{T,N} where {T,N}
data = gv.v
dim = findfirst(==(Symbol(gv.coordname)),Symbol.(dimnames(data)))
group_fun = gv.group_fun
groupmap = groupsubset(gv.groupmap,indices[dim])
nclass = ngroups(groupmap)
sz_all = ntuple(i -> (i == dim ? nclass : size(data,i) ),ndims(data))
sz = size_getindex(sz_all,indices...)
data_by_class = Array{T,length(sz)}(undef,sz)
data_by_class .= init
count = zeros(Int,nclass)
for k = 1:size(data,dim)
for ku in groupindices(groupmap,k)
dest_ind = _dest_indices(dim,ku,indices)
src_ind = ntuple(i -> (i == dim ? k : indices[i] ),ndims(data))
data_by_class_ind = view(data_by_class,dest_ind...)
data_by_class_ind .= reduce_op.(
data_by_class_ind,
map_fun(data[src_ind...]))
count[ku] += 1
end
end
return data_by_class,reshape(count,_indices(dim,length(count),1,indices))
end
function _mapreduce_aggregation(map_fun,ag,gv::GroupedVariable{TV},indices) where TV <: AbstractArray{T,N} where {T,N}
data = gv.v
dim = findfirst(==(Symbol(gv.coordname)),Symbol.(dimnames(data)))
group_fun = gv.group_fun
groupmap = groupsubset(gv.groupmap,indices[dim])
nclass = ngroups(groupmap)
sz_all = ntuple(i -> (i == dim ? nclass : size(data,i) ),ndims(data))
sz = size_getindex(sz_all,indices...)
data_by_class = fill(ag(T),sz)
count = zeros(Int,nclass)
for k = 1:size(data,dim)
for ku in groupindices(groupmap,k)
dest_ind = _dest_indices(dim,ku,indices)
src_ind = ntuple(i -> (i == dim ? k : indices[i] ),ndims(data))
data_by_class_ind = view(data_by_class,dest_ind...)
std_data_ind = map_fun(data[src_ind...])
data_by_class_ind .= update.(data_by_class_ind,std_data_ind)
end
end
return result.(data_by_class)
end
function _reduce(args...; kwargs...)
_mapreduce(identity,args...; kwargs...)
end
struct GroupedVariableStyle <: BroadcastStyle end
Base.BroadcastStyle(::Type{<:GroupedVariable}) = GroupedVariableStyle()
"""
A = find_gv(T,As)
returns the first type T among the arguments.
"""
find_gv(T,bc::Base.Broadcast.Broadcasted) = find_gv(T,bc.args)
find_gv(T,args::Tuple) = find_gv(T,find_gv(T,args[1]), Base.tail(args))
find_gv(T,x) = x
find_gv(T,::Tuple{}) = nothing
find_gv(::Type{T},a::T, rest) where T = a
find_gv(T,::Any, rest) = find_gv(T,rest)
function Base.similar(bc::Broadcasted{GroupedVariableStyle}, ::Type{ElType}) where ElType
A = find_gv(GroupedVariable,bc)
return A
end
function Base.broadcasted(::GroupedVariableStyle,f::Function,A::GroupedVariable{TV,TF,TGM,TM,TG}) where {TV,TF,TGM,TM,TG}
# TODO change output TG
map_fun = ∘(f,A.map_fun)
TM2 = typeof(map_fun)
TG2 = TG
ff = map_fun ∘ Array ∘ selectdim
#TG = Base.return_types(selectdim,(TV,Int,Int,))[1]
TG2 = Base.return_types(ff,(TV,Int,Int,))[1]
GroupedVariable{TV,TF,TGM,TM2,TG2}(
A.v,A.coordname,A.group_fun,A.groupmap,A.dim,map_fun)
end
function GroupedVariable(v::TV,coordname,group_fun::TF,groupmap,dim,map_fun::TM) where TV <: AbstractVariable where {TF,TM}
TGM = typeof(groupmap)
#TG = Base.return_types(selectdim,(TV,Int,Int,))[1]
TG = Base.return_types(_array_selectdim,(TV,Int,Vector{Int}))[1]
@debug "inferred types" TV TF TGM TM TG
# groupmap = GroupMapping(class,unique_class)
GroupedVariable{TV,TF,TGM,TM,TG}(
v,Symbol(coordname),group_fun,groupmap,dim,map_fun)
end
"""
gv = CommonDataModel.groupby(v::AbstractVariable,:coordname => group_fun)
gv = CommonDataModel.groupby(v::AbstractVariable,"coordname" => group_fun)
Create a grouped variable `gv` whose elements composed by all elements in `v`
whose corresponding coordinate variable (with the name `coordname`) map to the
same value once the group function `group_fun` is applied to the coordinate.
The grouped variable `gv` and be reduced using the functions `sum` `mean`,
`median`, `var` or `std`, for example `gr = mean(gv)`.
The result `gr` is a lazy structure representing the
outcome of these operations performed over the grouped dimension. Only when the
result `gr` is indexed the actually values are computed.
Broadcasting for `gv` and `gr` is overloaded. Broadcasting over all elements of
`gv` means that a mapping function is to be applied to all elements of `gv`
before a possible the reduction.
Broadcasting over `gr`, for example `v .- gr` mean that `gr` is broadcasted over the
full size of `v` according to the grouping function.
Example:
```julia
using NCDatasets, Dates
using CommonDataModel: @groupby, groupby
# create same test data
time = DateTime(2000,1,1):Day(1):DateTime(2009,12,31); # 10 years
data = rand(Float32.(-9:99),360,180,length(time));
fname = "test_file.nc"
ds = NCDataset(fname,"c");
defVar(ds,"time",time,("time",));
defVar(ds,"data",data,("lon","lat","time"));
# group over month
gv = @groupby(ds["data"],Dates.Month(time))
# or
# gv = groupby(ds["data"],:time => Dates.Month)
length(gv)
# output 12 as they are all 12 months in this dataset
size(gv[1])
# 360 x 180 x 310 array with all time slices corresponding to the 1st month
# the variable `gv` is equivalent to the following operation
time_month = Dates.Month.(ds[:time][:])
gv2 = [ds[:data][:,:,findall(time_month .== m)] for m in sort(unique(time_month))];
# compute basic statistics
using Statistics
monthly_mean = mean(gv);
size(monthly_mean)
# 360 x 180 x 12 array with the monthly mean
# get a regular julia array
monthly_mean_array = monthly_mean[:,:,:];
typeof(monthly_mean_array)
# Array{Float32, 3}
# substact from data the corresponding monthly mean
monthly_anomalies = data .- mean(gv);
close(ds)
```
"""
function groupby(v::AbstractVariable,(coordname,group_fun)::Pair{<:SymbolOrString,TF}) where TF
# for NCDatasets 0.12
c = v[String(coordname)][:]
class = group_fun.(c)
unique_class = sort(unique(class))
dim = findfirst(==(Symbol(coordname)),Symbol.(dimnames(v)))
map_fun = identity
groupmap = GroupMapping(class,unique_class)
return GroupedVariable(v,Symbol(coordname),group_fun,groupmap,dim,map_fun)
end
function groupby(ds::AbstractDataset,(coordname,group_fun)::Pair{<:SymbolOrString,TF}) where TF
c = ds[String(coordname)][:]
class = group_fun.(c)
unique_class = sort(unique(class))
map_fun = identity
groupmap = GroupMapping(class,unique_class)
return GroupedDataset(ds,Symbol(coordname),group_fun,groupmap,map_fun)
end
"""
gv = CommonDataModel.@groupby(v,group_fun(coordname))
Create a grouped variable `gv` whose elements are composed by all elements in `v`
whose corresponding coordinate variable (with the name `coordname`) map to the
same value once the group function `group_fun` is applied to the coordinate variable.
See [`groupby`](@ref CommonDataModel.groupby) for more information.
"""
macro groupby(vsym,expression)
(param, newsym),exp = scan_coordinate_name(expression)
fun = :($newsym -> $exp)
return :(groupby($(esc(vsym)),$(Meta.quot(param)) => $fun))
end
function ReducedGroupedVariable(gv::GroupedVariable,reduce_fun)
T = eltype(gv.v)
@debug "inference " T reduce_fun Base.return_types(reduce_fun, (Vector{T},))
N = ndims(gv.v)
_attrib = OrderedDict(gv.v.attrib)
ReducedGroupedVariable{T,N,typeof(gv),typeof(reduce_fun)}(gv,reduce_fun,_attrib)
end
function ReducedGroupedDataset(gds::GroupedDataset,reduce_fun)
return ReducedGroupedDataset(
gds.ds,
gds.coordname,
gds.group_fun,
gds.groupmap,
gds.map_fun,
reduce_fun,
)
end
"""
gr = reduce(f,gv::GroupedVariable)
Reduce the grouped variable `gv` along grouped dimension using the function `f`.
The function `f` will be called as `f(x,dims=d)` where `x` array (an element
of `gv`) and `d` is an integer of the dimension overwhich one need to reduce
`x`.
"""
Base.reduce(f::Function,gv::GroupedVariable) = ReducedGroupedVariable(gv,f)
Base.reduce(f::typeof(hcat),gv::GroupedVariable) = ReducedGroupedVariable(gv,f)
Base.reduce(f::typeof(vcat),gv::GroupedVariable) = ReducedGroupedVariable(gv,f)
Base.reduce(f::Function,gds::GroupedDataset) = ReducedGroupedDataset(gds,f)
for fun in (:maximum, :mean, :median, :minimum, :std, :sum, :var)
@eval $fun(gv::GroupedVariable) = reduce($fun,gv)
@eval $fun(gds::GroupedDataset) = reduce($fun,gds)
end
# methods with ReducedGroupedVariable as main argument
Base.ndims(gr::ReducedGroupedVariable) = ndims(gr.gv.v)
Base.size(gr::ReducedGroupedVariable) = ntuple(ndims(gr)) do i
if i == gr.gv.dim
length(gr.gv)
else
size(gr.gv.v,i)
end
end
dimnames(gr::ReducedGroupedVariable) = dimnames(gr.gv.v)
name(gr::ReducedGroupedVariable) = name(gr.gv.v)
attribnames(gr::ReducedGroupedVariable) = collect(keys(gr._attrib))
attrib(gr::ReducedGroupedVariable,attribname::SymbolOrString) = gr._attrib[attribname]
defAttrib(gr::ReducedGroupedVariable,attribname::SymbolOrString,value) =
gr._attrib[attribname] = value
struct ReducedGroupedVariableStyle <: BroadcastStyle end
Base.BroadcastStyle(::Type{<:ReducedGroupedVariable}) = ReducedGroupedVariableStyle()
Base.BroadcastStyle(::DefaultArrayStyle,::ReducedGroupedVariableStyle) = ReducedGroupedVariableStyle()
Base.BroadcastStyle(::ReducedGroupedVariableStyle,::DefaultArrayStyle) = ReducedGroupedVariableStyle()
function Base.similar(bc::Broadcasted{ReducedGroupedVariableStyle}, ::Type{ElType}) where ElType
# Scan the inputs for the ReducedGroupedVariable:
A = find_gv(ReducedGroupedVariable,bc)
return similar(A.gv.v)
end
# _array_selectdim_indices(ind,dim,i,sz...)
# returns a tuple (:,:,:,i,:,:,:) where the i is at the dim position
# in total there are as many indices as elements in the tuple sz
# (typically the size of the array)
_array_selectdim_indices(ind,dim,i,sz1,rest...) = _array_selectdim_indices((ind...,(length(ind) == dim-1 ? i : (:))),dim,i,rest...)
_array_selectdim_indices(ind,dim,i) = ind
# indices_B is not type-stable as dim is not know at compile type
# but if i is a range (e.g. 1:2), then the type-unstability does not propagate
function _array_selectdim(B,dim,i)
indices_B = _array_selectdim_indices((),dim,i,size(B)...)
return B[indices_B...]
end
_broadcasted_array_selectdim(A::ReducedGroupedVariable,dim,indices,k) = _array_selectdim(A,dim,k:k)
_broadcasted_array_selectdim(A,dim,indices,k) = _array_selectdim(A,dim,indices)
function broadcasted_gvr!(C,f,A,B)
gr = find_gv(ReducedGroupedVariable,(A,B))
gv = gr.gv
dim = gr.gv.dim
for k = 1:length(gv)
class_k, indices = group(gv,k)
selectdim(C,dim,indices) .= broadcast(
f,
_broadcasted_array_selectdim(A,dim,indices,k),
_broadcasted_array_selectdim(B,dim,indices,k))
end
return C
end
Base.broadcasted(::ReducedGroupedVariableStyle,f::Function,A,B::ReducedGroupedVariable) =
broadcasted_gvr!(similar(A),f,A,B)
Base.broadcasted(::ReducedGroupedVariableStyle,f::Function,A::ReducedGroupedVariable,B) =
broadcasted_gvr!(similar(B),f,A,B)
function Base.broadcasted(::ReducedGroupedVariableStyle,f::Function,A::ReducedGroupedVariable,B::ReducedGroupedVariable)
# undecided what to do
# method needs to be there to avoid ambiguities
error("unimplemented");
end
function Base.Array(gr::ReducedGroupedVariable)
gr[ntuple(i -> Colon(),ndims(gr))...]
end
function Base.getindex(gr::ReducedGroupedVariable{T,N,TGV,typeof(sum)},indices::TIndices...) where {T,N,TGV}
data,count = _mapreduce(gr.gv.map_fun,+,gr.gv,indices)
data
end
function Base.getindex(gr::ReducedGroupedVariable{T,N,TGV,typeof(mean)},indices::TIndices...) where {T,N,TGV}
data,count = _mapreduce(gr.gv.map_fun,+,gr.gv,indices)
data ./ count
end
function Base.getindex(gr::ReducedGroupedVariable{T,N,TGV,TF},indices::TIndices...) where TF <: Union{typeof(var),typeof(maximum),typeof(minimum)} where {T,N,TGV}
return _mapreduce_aggregation(
gr.gv.map_fun,aggregator(TF),gr.gv,indices);
end
function Base.getindex(gr::ReducedGroupedVariable{T,N,TGV,typeof(std)},indices::TIndices...) where {T,N,TGV}
return sqrt.(_mapreduce_aggregation(
gr.gv.map_fun,VarianceWelfordAggregation,gr.gv,indices))
end
_dim_after_getindex(dim,ind::TIndices,other...) = _dim_after_getindex(dim+1,other...)
_dim_after_getindex(dim,ind::Integer,other...) = _dim_after_getindex(dim,other...)
_dim_after_getindex(dim) = dim
function Base.getindex(gr::ReducedGroupedVariable{T},indices::TIndices...) where T
gv = gr.gv
sz = size_getindex(gr,indices...)
data_by_class = Array{T}(undef,sz)
# after indexing some dimensions are not longer present
cdim = _dim_after_getindex(0,indices[1:(gv.dim-1)]...) + 1
indices_source = ntuple(ndims(gr)) do i
if i == gv.dim
(:)
else
indices[i]
end
end
for (kl,ku) in enumerate(to_indices(gr,indices)[gv.dim])
dest_ind = _dest_indices(gv.dim,kl,indices)
data = gv[ku]
data_by_class[dest_ind...] = gr.reduce_fun(gv.map_fun(data[indices_source...]),dims=cdim)
end
return data_by_class
end
function dataset(gr::ReducedGroupedVariable)
gv = gr.gv
ds = dataset(gv.v)
return ReducedGroupedDataset(
ds,gv.coordname,gv.group_fun,
gv.groupmap,
gv.map_fun,
gr.reduce_fun,
)
end
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 6447 | import CommonDataModel as CDM
Base.size(RA::ResizableArray) = size(RA.A)
Base.getindex(RA::ResizableArray,inds...) = getindex(RA.A,inds...)
@inline _checkbounds(RA::ResizableArray,inds...) = all(minimum.(inds) .> 0)
@inline Base.checkbounds(::Type{Bool},RA::ResizableArray,inds::Union{Integer,AbstractVector{<:Integer}}...) =
_checkbounds(RA,inds...)
@inline checkbounds(::Type{Bool}, itp::ResizableArray, inds::LogicalIndex) =
_checkbounds(RA,inds...)
@inline checkbounds(::Type{Bool}, itp::ResizableArray, inds::LogicalIndex{<:Any,<:AbstractVector{Bool}}) =
_checkbounds(RA,inds...)
function grow!(RA::ResizableArray{T,N},new_size) where {T,N}
# grow
oldA = RA.A
RA.A = Array{T,N}(undef,new_size)
RA.A .= RA.fillvalue
RA.A[axes(oldA)...] = oldA
end
function Base.setindex!(RA::ResizableArray{T,N}, value, inds::Vararg{Int, N}) where {T,N}
sz = max.(size(RA),inds)
if sz != size(RA)
grow!(RA,sz)
end
RA.A[inds...] = value
end
function _root(ds::Union{MemoryVariable,MemoryDataset})
if isnothing(ds.parent_dataset)
return ds
else
return _root(ds.parent_dataset)
end
end
function grow_unlimited_dimension(ds,dname,len)
if haskey(ds.dimensions,dname)
ds.dimensions[dname] = len
end
for (varname,var) in ds.variables
new_size = ntuple(ndims(var)) do j
if dimnames(var)[j] == dname
len
else
size(var,j)
end
end
if new_size != size(var)
grow!(var.data,new_size)
end
end
for (groupname,group) in ds._group
grow_unlimited_dimension(group,dname,len)
end
end
Base.getindex(v::MemoryVariable,ij::TIndices...) = v.data[ij...]
CDM.load!(v::MemoryVariable,buffer,ij...) = buffer .= view(v.data,ij...)
function Base.setindex!(v::MemoryVariable,data,ij...)
sz = size(v.data)
v.data[ij...] = data
root = _root(v)
for idim = findall(size(v) .> sz)
dname = v.dimnames[idim]
grow_unlimited_dimension(v.parent_dataset,dname,size(v,idim))
end
return data
end
Base.size(v::MemoryVariable) = size(v.data)
CDM.name(v::Union{MemoryVariable,MemoryDataset}) = v.name
CDM.dimnames(v::MemoryVariable) = v.dimnames
CDM.dataset(v::MemoryVariable) = v.parent_dataset
Base.keys(md::MemoryDataset) = keys(md.variables)
CDM.variable(md::MemoryDataset,varname::SymbolOrString) = md.variables[String(varname)]
CDM.dimnames(md::MemoryDataset) = keys(md.dimensions)
CDM.maskingvalue(md::MemoryDataset) = md.maskingvalue
function CDM.unlimited(md::MemoryDataset)
ul = md.unlimited
if md.parent_dataset != nothing
append!(ul,unlimited(md.parent_dataset))
end
return ul
end
function _dim(md::MemoryDataset,name::SymbolOrString)
if haskey(md.dimensions,String(name))
return md.dimensions[String(name)]
elseif md.parent_dataset !== nothing
return _dim(md.parent_dataset,name)
end
return nothing
end
function CDM.dim(md::MemoryDataset,name::SymbolOrString)
len = _dim(md,name)
if !isnothing(len)
return len
else
error("dimension $name not found")
end
end
CDM.varnames(ds::MemoryDataset) = collect(keys(ds.variables))
CDM.attribnames(md::Union{MemoryDataset,MemoryVariable}) = keys(md._attrib)
CDM.attrib(md::Union{MemoryDataset,MemoryVariable},name::SymbolOrString) = md._attrib[String(name)]
CDM.groupnames(md::MemoryDataset) = keys(md._group)
CDM.group(md::MemoryDataset,name::SymbolOrString) = md._group[String(name)]
function CDM.defDim(md::MemoryDataset,name::SymbolOrString,len)
if isinf(len)
md.dimensions[String(name)] = 0
push!(md.unlimited,String(name))
else
md.dimensions[String(name)] = len
end
end
function CDM.defVar(md::MemoryDataset,name::SymbolOrString,T::DataType,dimnames;
fillvalue = nothing,
attrib = OrderedDict{SymbolOrString,Any}(),
)
sz = ntuple(i -> CDM.dim(md,dimnames[i]),length(dimnames))
if length(intersect(dimnames,CDM.unlimited(md))) == 0
data = Array{T,length(dimnames)}(undef,sz...)
else
fv =
if !isnothing(fillvalue)
T(fillvalue)
elseif haskey(attrib,"_FillValue")
T(attrib["_FillValue"])
else
T(0)
end
data_ = Array{T,length(dimnames)}(undef,sz...)
data = ResizableArray(data_,fv)
end
attrib_ = OrderedDict{String,Any}()
for (k,v) in attrib
attrib_[String(k)] = v
end
mv = MemoryVariable(md,String(name),(String.(dimnames)...,), data, attrib_)
if fillvalue !== nothing
mv.attrib["_FillValue"] = fillvalue
end
md.variables[String(name)] = mv
cfvar = md[String(name)]
return cfvar
end
function CDM.defAttrib(md::Union{MemoryVariable,MemoryDataset},name::SymbolOrString,data)
md._attrib[String(name)] = data
end
function CDM.delAttrib(md::Union{MemoryVariable,MemoryDataset},name::SymbolOrString)
delete!(md._attrib,String(name))
end
function CDM.defGroup(md::MemoryDataset,name::SymbolOrString);
md._group[String(name)] = MemoryDataset(; parent_dataset = md, name = name)
end
CDM.parentdataset(md::MemoryDataset) = md.parent_dataset
CDM.iswritable(md::MemoryDataset) = true
function MemoryDataset(; parent_dataset = nothing, name = "/",
attrib = OrderedDict{String,Any}(),
maskingvalue = missing
)
return MemoryDataset(
parent_dataset,
name,
OrderedDict{String,Int}(),
OrderedDict{String,MemoryVariable}(),
OrderedDict{String,Any}(attrib),
String[],
OrderedDict{String,Any}(),
maskingvalue
)
end
const MEMORY_DATASET_STORE = Dict{String,Any}()
function MemoryDataset(key,mode = "r"; kwargs...)
if mode == "c"
md = MemoryDataset(; kwargs...);
MEMORY_DATASET_STORE[key] = md
return md
elseif mode == "r" || mode == "a"
return MEMORY_DATASET_STORE[key]
end
end
MemoryDataset(keys::AbstractArray{<:AbstractString,N}, args...; kwargs...) where N =
MFDataset(MemoryDataset,keys, args...; kwargs...)
function MemoryDataset(f::Function,args...; kwargs...)
ds = MemoryDataset(args...; kwargs...)
try
f(ds)
finally
close(ds)
end
end
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 7941 |
attribnames(ds::MFDataset) = attribnames(ds.ds[1])
attrib(ds::MFDataset,name::SymbolOrString) = attrib(ds.ds[1],name)
attribnames(v::Union{MFCFVariable,MFVariable}) = attribnames(variable(v.ds.ds[1],v.varname))
attrib(v::Union{MFCFVariable,MFVariable},name::SymbolOrString) = attrib(variable(v.ds.ds[1],v.varname),name)
function defAttrib(v::Union{MFCFVariable,MFVariable},name::SymbolOrString,data)
for ds in v.ds.ds
defAttrib(variable(v.ds,v.varname),name,data)
end
return data
end
function defAttrib(ds::MFDataset,name::SymbolOrString,data)
for _ds in ds.ds
defAttrib(_ds,name,data)
end
return data
end
function dim(ds::MFDataset,name::SymbolOrString)
if name == ds.aggdim
if ds.isnewdim
return length(ds.ds)
else
return sum(dim(_ds,name) for _ds in ds.ds)
end
else
return dim(ds.ds[1],name)
end
end
function defDim(ds::MFDataset,name::SymbolOrString,data)
for _ds in ds.ds
defDim(_ds,name,data)
end
return data
end
function dimnames(ds::MFDataset)
k = collect(dimnames(ds.ds[1]))
if ds.isnewdim
push!(k,ds.aggdim)
end
return k
end
unlimited(ds::MFDataset) = unique(reduce(hcat,unlimited.(ds.ds)))
groupnames(ds::MFDataset) = groupnames(ds.ds[1])
function group(mfds::MFDataset,name::SymbolOrString)
ds = group.(mfds.ds,name)
constvars = Symbol[]
return MFDataset(ds,mfds.aggdim,mfds.isnewdim,constvars)
end
function parentdataset(mfds::MFDataset)
ds = parentdataset.(mfds.ds)
if isnothing(ds[1])
return nothing
else
return MFDataset(ds,mfds.aggdim,mfds.isnewdim,mfds.constvars)
end
end
Base.Array(v::MFVariable) = Array(v.var)
iswritable(mfds::MFDataset) = iswritable(mfds.ds[1])
function MFDataset(ds,aggdim,isnewdim,constvars)
_boundsmap = Dict{String,String}()
mfds = MFDataset(ds,aggdim,isnewdim,constvars,_boundsmap)
if !iswritable(mfds)
initboundsmap!(mfds)
end
return mfds
end
function MFDataset(TDS,fnames::AbstractArray{<:AbstractString,N},mode = "r"; aggdim = nothing,
deferopen = true,
_aggdimconstant = false,
isnewdim = false,
constvars = Union{Symbol,String}[],
) where N
if !(mode == "r" || mode == "a")
throw(ArgumentError("""Unsupported mode for multi-file dataset (mode = $(mode)). Mode must be "r" or "a"."""))
end
if deferopen
@assert mode == "r"
if _aggdimconstant
# load only metadata from master
master_index = 1
ds_master = TDS(fnames[master_index],mode);
data_master = metadata(ds_master)
ds = Vector{Union{TDS,DeferDataset}}(undef,length(fnames))
#ds[master_index] = ds_master
for (i,fname) in enumerate(fnames)
#if i !== master_index
ds[i] = DeferDataset(TDS,fname,mode,data_master)
#end
end
else
ds = DeferDataset.(TDS,fnames,mode)
end
else
ds = TDS.(fnames,mode);
end
if (aggdim == nothing) && !isnewdim
# first unlimited dimensions
aggdim = unlimited(ds[1].dim)[1]
end
mfds = MFDataset(ds,aggdim,isnewdim,Symbol.(constvars))
return mfds
end
function close(mfds::MFDataset)
close.(mfds.ds)
return nothing
end
function sync(mfds::MFDataset)
sync.(mfds.ds)
return nothing
end
function path(mfds::MFDataset)
path(mfds.ds[1]) * "…" * path(mfds.ds[end])
end
name(mfds::MFDataset) = name(mfds.ds[1])
# to depreciate?
groupname(mfds::MFDataset) = name(mfds.ds[1])
function Base.keys(mfds::MFDataset)
if mfds.aggdim == ""
return unique(Iterators.flatten(keys.(mfds.ds)))
else
keys(mfds.ds[1])
end
end
Base.getindex(v::MFVariable,indexes::TIndices...) = getindex(v.var,indexes...)
Base.setindex!(v::MFVariable,data,indexes::TIndices...) = setindex!(v.var,data,indexes...)
load!(v::MFVariable,buffer,indexes...) = CatArrays.load!(v.var,buffer,indexes...)
Base.size(v::MFVariable) = size(v.var)
Base.size(v::MFCFVariable) = size(v.var)
dimnames(v::MFVariable) = v.dimnames
name(v::MFVariable) = v.varname
function variable(mfds::MFDataset,varname::SymbolOrString)
if mfds.isnewdim
if Symbol(varname) in mfds.constvars
return variable(mfds.ds[1],varname)
end
# aggregated along a given dimension
vars = variable.(mfds.ds,varname)
v = CatArrays.CatArray(ndims(vars[1])+1,vars...)
return MFVariable(mfds,v,
(dimnames(vars[1])...,mfds.aggdim),String(varname))
elseif mfds.aggdim == ""
# merge all variables
# the latest dataset should be used if a variable name is present multiple times
for ds in reverse(mfds.ds)
if haskey(ds,varname)
return variable(ds,varname)
end
end
else
# aggregated along a given dimension
vars = variable.(mfds.ds,varname)
dim = findfirst(dimnames(vars[1]) .== mfds.aggdim)
@debug "dimension $dim"
if (dim != nothing)
v = CatArrays.CatArray(dim,vars...)
return MFVariable(mfds,v,
dimnames(vars[1]),String(varname))
else
return vars[1]
end
end
end
function cfvariable(mfds::MFDataset,varname::SymbolOrString)
if mfds.isnewdim
if Symbol(varname) in mfds.constvars
return cfvariable(mfds.ds[1],varname)
end
# aggregated along a given dimension
cfvars = cfvariable.(mfds.ds,varname)
cfvar = CatArrays.CatArray(ndims(cfvars[1])+1,cfvars...)
var = variable(mfds,varname)
return MFCFVariable(mfds,cfvar,var,
dimnames(var),varname)
elseif mfds.aggdim == ""
# merge all variables
# the latest dataset should be used if a variable name is present multiple times
for ds in reverse(mfds.ds)
if haskey(ds,varname)
return cfvariable(ds,varname)
end
end
else
# aggregated along a given dimension
cfvars = cfvariable.(mfds.ds,varname)
dim = findfirst(dimnames(cfvars[1]) .== mfds.aggdim)
@debug "dim $dim"
if (dim != nothing)
cfvar = CatArrays.CatArray(dim,cfvars...)
var = variable(mfds,varname)
return MFCFVariable(mfds,cfvar,var,
dimnames(var),String(varname))
else
return cfvars[1]
end
end
end
dataset(v::Union{MFVariable,MFCFVariable}) = v.ds
Base.getindex(v::MFCFVariable,ind::TIndices...) = v.cfvar[ind...]
Base.setindex!(v::MFCFVariable,data,ind::TIndices...) = v.cfvar[ind...] = data
function Base.cat(vs::AbstractVariable...; dims::Integer)
CatArrays.CatArray(dims,vs...)
end
"""
storage,chunksizes = chunking(v::MFVariable)
storage,chunksizes = chunking(v::MFCFVariable)
Return the storage type (`:contiguous` or `:chunked`) and the chunk sizes of the varable
`v` corresponding to the first file. If the first file in the collection
is chunked then this storage attributes are returned. If not the first file is not contiguous, then multi-file variable is still reported as chunked with chunk size equal to the size of the first variable.
"""
function chunking(v::MFVariable)
v1 = v.ds.ds[1][name(v)]
storage,chunksizes = chunking(v1)
if storage == :contiguous
return (:chunked, size(v1))
else
return storage,chunksizes
end
end
deflate(v::MFVariable) = deflate(v.ds.ds[1][name(v)])
checksum(v::MFVariable) = checksum(v.ds.ds[1][name(v)])
chunking(v::MFCFVariable) = chunking(v.var)
deflate(v::MFCFVariable) = deflate(v.var)
checksum(v::MFCFVariable) = checksum(v.var)
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 5389 | # rolling means (also called running means) and other reductions
struct OverlappingGroupMapping{T,TRC} <: AbstractGroupMapping
coord::Vector{T}
rolling_classes::TRC
groupindex_to_dataindex::Vector{Vector{Int}}
dataindex_to_groupindex::Vector{Vector{Int}}
end
# multiple classes for overlapping groups
struct MClass{T <: NTuple}
class::T
end
Base.length(mc::MClass) = 1
Base.getindex(mc::MClass,i) = mc
Base.in(item,collection::MClass) = item in collection.class
function OverlappingGroupMapping(coord::AbstractVector{T},rolling_classes) where T
# k is data index
# ku is the group index
coord_to_dataindex = Dict{T,Int}()
for k = 1:length(coord)
coord_to_dataindex[coord[k]] = k
end
groupindex_to_dataindex = [Int[] for i in 1:length(rolling_classes)]
dataindex_to_groupindex = [Int[] for i in 1:length(coord)]
for ku = 1:length(rolling_classes)
for class in rolling_classes[ku].class
k = get(coord_to_dataindex,class,nothing)
if !isnothing(k)
push!(groupindex_to_dataindex[ku],k)
push!(dataindex_to_groupindex[k],ku)
end
end
end
return OverlappingGroupMapping(coord,rolling_classes,groupindex_to_dataindex,dataindex_to_groupindex)
end
dataindices(gmap::OverlappingGroupMapping,ku) = gmap.groupindex_to_dataindex[ku]
groupindices(gmap::OverlappingGroupMapping,k) = gmap.dataindex_to_groupindex[k]
ngroups(gmap::OverlappingGroupMapping) = length(gmap.groupindex_to_dataindex)
ndata(gmap::OverlappingGroupMapping) = length(gmap.dataindex_to_groupindex)
function groupsubset(gmap::OverlappingGroupMapping,kus)
OverlappingGroupMapping(gmap.coord,gmap.rolling_classes[kus])
end
groupsubset(gmap::OverlappingGroupMapping,kus::Colon) = gmap
grouplabel(gmap::OverlappingGroupMapping,ku) = gmap.rolling_classes[ku].class
#--------------
"""
gv = CommonDataModel.rolling(v::AbstractVariable,:coordname => n)
gv = CommonDataModel.rolling(v::AbstractVariable,:coordname => rolling_classes)
Create a grouped variable `gv` whose elements composed by all elements in `v`
grouped by a rolling window of length `n` along the coordinate variable `coordname`.
One can also specify a vector classes (`rolling_classes`) with as many elements
as they are groups and the elements coorespond to the values of the coordinate.
Unlike `CommonDataModel.groupby`, the groups defined by `rolling` can overlap.
The grouped variable `gv` and be reduced using the functions `sum` `mean`,
`median`, `var` or `std`, for example `gr = mean(gv)`.
The result `gr` is a lazy structure representing the
outcome of these operations performed over the grouped dimension. Only when the
result `gr` is indexed the actually values are computed.
Broadcasting for `gv` is overloaded. Broadcasting over all elements of
`gv` means that a mapping function is to be applied to all elements of `gv`
before a possible the reduction.
This operations is also called "running mean" when using `mean` as reduction
function.
Example:
```julia
using NCDatasets, Dates
using CommonDataModel: rolling
# create same test data
time = DateTime(2000,1,1):Day(1):DateTime(2009,12,31); # 10 years
data = rand(Float32.(-9:99),360,180,length(time));
fname = "test_file.nc"
ds = NCDataset(fname,"c");
defVar(ds,"time",time,("time",));
defVar(ds,"data",data,("lon","lat","time"));
# running weekly mean
gv = rolling(ds["data"],:time => 7)
length(gv)
# output 3653 as a mean will be compute for all time instance (including a
# partial mean and the beginning and the end)
size(gv[1])
# output 360 x 180 x 4: the first time slice will only be a mean of 4 values
size(gv[4])
# output 360 x 180 x 7: data from the first 7 days
# compute basic statistics
using Statistics
weekly_running_mean = mean(gv);
size(weekly_running_mean)
# 360 x 180 x 3653 array with the running weekly mean
# get a regular julia array
weekly_running_mean_array = weekly_running_mean[:,:,:];
typeof(weekly_running_mean_array)
# Array{Float32, 3}
# computing a centred 3 monthly mean taking into account that month do not have the
# same length
rolling_classes = [(t - Dates.Month(1)):Day(1):(t + Dates.Month(1)) for t in time]
extrema(length.(rolling_classes))
# output (60, 63)
data_3monthly = mean(rolling(ds["data"],:time => rolling_classes))[:,:,:];
close(ds)
```
"""
function rolling(v,(coordname,rolling_classes)::Pair)
coord = v[coordname][:]
_rolling(v,coord,coordname,rolling_classes)
end
function _rolling(v,coord,coordname::SymbolOrString,rolling_classes::AbstractVector)
rolling_classes_ = [MClass(tuple(r...)) for r in rolling_classes]
groupmap = OverlappingGroupMapping(coord,rolling_classes_)
group_fun = identity # still necessary?
dim = findfirst(==(Symbol(coordname)),Symbol.(dimnames(v)))
map_fun = identity
return GroupedVariable(v,coordname,group_fun,groupmap,dim,map_fun)
end
function _rolling(v,coord,coordname::SymbolOrString,nn::Integer)
# if nn = 7, n0:n1 = -3:3
# if nn = 8, n0:n1 = -4:3
# for even nn where are biased towards lower indices as in xarray
# for odd nn where are perfectly centred
n0 = nn ÷ 2
n1 = nn - n0 - 1
rolling_classes = [coord[max(n-n0,1):min(n+n1,length(coord))]
for n = 1:length(coord)]
return _rolling(v,coord,coordname,rolling_classes)
end
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 12195 | import Base: findfirst
struct Near{TTarget,TTolerance}
target::TTarget
tolerance::TTolerance
end
Near(target) = Near(target,nothing)
function _findfirst(n::Near,v::AbstractVector)
diff, ind = findmin(x -> abs(x - n.target),v)
if (n.tolerance != nothing) && (diff > n.tolerance)
return Int[]
else
return ind
end
end
function scan_exp!(exp::Symbol,found)
if haskey(found,exp)
return found[exp]
else
newsym = gensym()
found[exp] = newsym
return newsym
end
end
function scan_exp!(exp::Expr,found)
if exp.head == :$
return exp.args[1]
end
if exp.head == :call
# skip function name
return Expr(exp.head,exp.args[1],scan_exp!.(exp.args[2:end],Ref(found))...)
elseif exp.head == :comparison
# :(3 <= lon <= 7.2)
args = Vector{Any}(undef,length(exp.args))
for i = 1:length(exp.args)
if iseven(i)
# skip inflix operators
args[i] = exp.args[i]
else
args[i] = scan_exp!(exp.args[i],found)
end
end
return Expr(exp.head,args...)
else
return Expr(exp.head,scan_exp!.(exp.args[1:end],Ref(found))...)
end
end
# neither Expr nor Symbol
scan_exp!(exp,found) = exp
function scan_exp(exp::Expr)
found = Dict{Symbol,Symbol}()
exp = scan_exp!(exp,found)
return found,exp
end
function scan_coordinate_name(exp)
params,exp = scan_exp(exp)
if length(params) != 1
error("Multiple (or none) coordinates in expression $exp ($params) while looking for $(coordinate_names).")
end
param = first(params)
return param,exp
end
function split_by_and!(exp,sub_exp)
if exp.head == :&&
split_by_and!(exp.args[1],sub_exp)
split_by_and!(exp.args[2],sub_exp)
else
push!(sub_exp,exp)
end
return sub_exp
end
split_by_and(exp) = split_by_and!(exp,[])
_intersect(r1::AbstractVector,r2::AbstractVector) = intersect(r1,r2)
_intersect(r1::AbstractVector,r2::Number) = (r2 in r1 ? r2 : [])
_intersect(r1::Number,r2::Number) = (r2 == r1 ? r2 : [])
_intersect(r1::Colon,r2) = r2
_intersect(r1::Colon,r2::AbstractRange) = r2
"""
vsubset = CommonDataModel.@select(v,expression)
dssubset = CommonDataModel.@select(ds,expression)
Return a subset of the variable `v` (or dataset `ds`) satisfying the condition `expression` as a view. The condition
has the following form:
`condition₁ && condition₂ && condition₃ ... conditionₙ`
Every condition should involve a single 1D variable (typically a coordinate variable, referred as `coord` below). If `v`
is a variable, the related 1D variable should have a shared dimension with the variable `v`. All local variables need to have a `\$` prefix (see examples below). This macro is experimental and subjected to change.
Every condition can either perform:
* a nearest match: `coord ≈ target_coord` (for `≈` type `\\approx` followed by the TAB-key). Only the data corresponding to the index closest to `target_coord` is loaded.
* a nearest match with tolerance: `coord ≈ target_coord ± tolerance`. As before, but if the difference between the closest value in `coord` and `target_coord` is larger (in absolute value) than `tolerance`, an empty array is returned.
* a condition operating on scalar values. For example, a `condition` equal to `10 <= lon <= 20` loads all data with the longitude between 10 and 20 or `abs(lat) > 60` loads all variables with a latitude north of 60° N and south of 60° S (assuming that the has the 1D variables `lon` and `lat` for longitude and latitude).
Only the data which satisfies all conditions is loaded. All conditions must be chained with an `&&` (logical and). They should not contain additional parenthesis or other logical operators such as `||` (logical or).
To convert the view into a regular array one can use `collect`, `Array` or regular indexing.
As in julia, views of scalars are wrapped into a zero dimensional arrays which can be dereferenced by using `[]`. Modifying a view will modify the underlying file (if
the file is opened as writable, otherwise an error is issued).
As for any view, one can use `parentindices(vsubset)` to get the indices matching a select query.
## Examples
Create a sample file with random data:
```julia
using NCDatasets, Dates
using CommonDataModel: @select
# or
# using NCDatasets: @select
fname = "sample_file.nc"
lon = -180:180
lat = -90:90
time = DateTime(2000,1,1):Day(1):DateTime(2000,1,3)
SST = randn(length(lon),length(lat),length(time))
ds = NCDataset(fname,"c")
defVar(ds,"lon",lon,("lon",));
defVar(ds,"lat",lat,("lat",));
defVar(ds,"time",time,("time",));
defVar(ds,"SST",SST,("lon","lat","time"));
# load by bounding box
v = @select(ds["SST"],30 <= lon <= 60 && 40 <= lat <= 80)
# substitute a local variable in condition using \$
lonr = (30,60) # longitude range
latr = (40,80) # latitude range
v = @select(ds["SST"],\$lonr[1] <= lon <= \$lonr[2] && \$latr[1] <= lat <= \$latr[2])
# You can also select based on `ClosedInterval`s from `IntervalSets.jl`.
# Both 30..60 and 60 ± 20 construct `ClosedInterval`s, see their documentation for details.
lon_interval = 30..60
lat_interval = 60 ± 20
v = @select(ds["SST"], lon ∈ \$lon_interval && lat ∈ \$lat_interval)
# get the indices matching the select query
(lon_indices,lat_indices,time_indices) = parentindices(v)
# get longitude matchting the select query
v_lon = v["lon"]
# find the nearest time instance
v = @select(ds["SST"],time ≈ DateTime(2000,1,4))
# find the nearest time instance but not earlier or later than 2 hours
# an empty array is returned if no time instance is present
v = @select(ds["SST"],time ≈ DateTime(2000,1,3,1) ± Hour(2))
close(ds)
```
Any 1D variable with the same dimension name can be used in `@select`. For example,
if we have a time series of temperature and salinity, the temperature values
can also be selected based on salinity:
```julia
using NCDatasets, Dates
using CommonDataModel: @select
fname = "sample_series.nc"
# create a sample time series
time = DateTime(2000,1,1):Day(1):DateTime(2009,12,31)
salinity = randn(length(time)) .+ 35
temperature = randn(length(time))
NCDataset(fname,"c") do ds
defVar(ds,"time",time,("time",));
defVar(ds,"salinity",salinity,("time",));
defVar(ds,"temperature",temperature,("time",));
end
ds = NCDataset(fname)
# load all temperature data from January where the salinity is larger than 35.
v = @select(ds["temperature"],Dates.month(time) == 1 && salinity >= 35)
# this is equivalent to:
v2 = ds["temperature"][findall(Dates.month.(time) .== 1 .&& salinity .>= 35)]
v == v2
# returns true
close(ds)
```
!!! note
For optimal performance, one should try to load contiguous data ranges, in
particular when the data is loaded over HTTP/OPeNDAP.
"""
macro select(v,expression)
expression_list = split_by_and(expression)
args = Vector{Any}(undef,length(expression_list))
# loop over all sub-expressions separated by &&
for (i,e) in enumerate(expression_list)
(param,newsym),e = scan_coordinate_name(e)
if (e.head == :call) && (e.args[1] == :≈)
@assert e.args[2] == newsym
target = e.args[3]
tolerance = nothing
if (hasproperty(target,:head) &&
(target.head == :call) && (target.args[1] == :±))
value,tolerance = target.args[2:end]
else
value = target
end
args[i] = quote
$(Meta.quot(param)) => Near($(esc(value)),$tolerance)
end
else
fun = Expr(:->,newsym,e)
args[i] = quote
$(Meta.quot(param)) => $(esc(fun))
end
end
end
return Expr(:call,:select,esc(v),args...)
end
# transform the ranges if possible to avoid issue
# https://github.com/meggart/DiskArrays.jl/issues/138
# for the most common case
_maybetorange(v) = v
function _maybetorange(v::AbstractVector)
if isempty(v)
return v
end
r = v[begin]:v[end]
if v == r
return r
else
return v
end
end
"""
vsubset = CommonDataModel.select(v,param1 => condition1, param2 => condition2,...)
dssubset = CommonDataModel.select(ds,param1 => condition1, param2 => condition2,...)
Return a subset of the variable `v` (or dataset `ds`) satisfying the conditions
applied to the corresponding parameters. `param1`, `param2` ... are symbols or
strings with variable names and `condition1`, `condition2` ... are functions
taking as a argument the values of the corresponding parameter and return
either false (ignore the corresponding elements) or true (select the
corresponding elements for loading).
## Examples
Create a sample file with random data:
```julia
using NCDatasets, Dates
using CommonDataModel: select, Near
fname = "sample_file.nc"
lon = -180:180
lat = -90:90
time = DateTime(2000,1,1):Day(1):DateTime(2000,1,3)
SST = randn(length(lon),length(lat),length(time));
ds = NCDataset(fname,"c")
defVar(ds,"lon",lon,("lon",));
defVar(ds,"lat",lat,("lat",));
defVar(ds,"time",time,("time",));
defVar(ds,"SST",SST,("lon","lat","time"));
# load by bounding box
v = select(ds["SST"],
:lon => lon -> 30 <= lon <= 60,
:lat => lat -> 40 <= lat <= 80)
# You can also select based on `ClosedInterval`s from `IntervalSets.jl`.
# Both 30..60 and 60 ± 20 construct `ClosedInterval`s, see their documentation for details. `∈` can be typed `\\in` followed by the TAB-key.
using IntervalSets
v = select(ds["SST"], :lon => ∈(30..60), :lat => ∈(60 ± 20))
# get the indices matching the select query
(lon_indices,lat_indices,time_indices) = parentindices(v)
# get longitude matchting the select query
v_lon = v["lon"]
# find the nearest time instance
v = select(ds["SST"],:time => Near(DateTime(2000,1,4)))
# find the nearest time instance but not earlier or later than 2 hours
# an empty array is returned if no time instance is present
v = select(ds["SST"],:time => Near(DateTime(2000,1,3,1),Hour(2)))
close(ds)
```
See also [`@select`](@ref CommonDataModel.@select) for more information.
"""
function select(v,conditions...)
coord_names = coordinate_names(v)
if v isa AbstractArray
indices = Any[Colon() for _ in 1:ndims(v)]
else
indices = Dict{Symbol,Any}(((Symbol(d),Colon()) for d in dimnames(v)))
end
for (param,condition) in conditions
coord,j = coordinate_value(v,param)
if isa(condition,Near)
ind = _findfirst(condition,coord)
indices[j] = _intersect(indices[j],ind)
else
ind = findall(condition,coord)
indices[j] = _intersect(indices[j],ind)
end
end
if v isa AbstractArray
view(v, _maybetorange.(indices)...)
else
view(v; ((k=>_maybetorange(v)) for (k,v) in indices)...)
end
end
function coordinate_value(v::AbstractVariable,name_coord::Symbol)
ncv = dataset(v)[name_coord]
@assert ndims(ncv) == 1
dimension_name = dimnames(ncv)[1]
i = findfirst(==(dimension_name),dimnames(v))
fmtd(v) = join(dimnames(v),"×")
if i == nothing
error("$name_coord (dimensions: $(fmtd(ncv))) and $(name(v)) (dimensions: $(fmtd(v))) do not share a named dimension")
end
return Array(ncv),i
end
function coordinate_names(v::AbstractVariable)
ds = dataset(v)
dimension_names = dimnames(v)
return [Symbol(varname) for (varname,ncvar) in ds
if (ndims(ncvar) == 1) && dimnames(ncvar) ⊆ dimension_names]
end
function coordinate_value(ds::AbstractDataset,name_coord::Symbol)
ncv = ds[name_coord]
@assert ndims(ncv) == 1
return Array(ncv),Symbol(dimnames(ncv)[1])
end
function coordinate_names(ds::AbstractDataset)
return [Symbol(varname) for (varname,ncvar) in ds
if (ndims(ncvar) == 1)]
end
# LocalWords: params vsubset conditionN NetCDF coord NCDatasets lon
# LocalWords: julia dereferenced parentindices fname nc DateTime ds
# LocalWords: randn NCDataset defVar lonr latr CFTime OPeNDAP args
# LocalWords: hasproperty esc Expr fmtd ncv
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 5751 |
Base.parent(v::SubVariable) = v.parent
Base.parentindices(v::SubVariable) = v.indices
Base.size(v::SubVariable) = _shape_after_slice(size(v.parent),v.indices...)
function dimnames(v::SubVariable)
dimension_names = dimnames(v.parent)
return dimension_names[map(i -> !(i isa Integer),collect(v.indices))]
end
name(v::SubVariable) = name(v.parent)
attribnames(v::SubVariable) = attribnames(v.parent)
attrib(v::SubVariable,name::SymbolOrString) = attrib(v.parent,name)
defAttrib(v::SubVariable,name::SymbolOrString,data) = defAttrib(v.parent,name,data)
function SubVariable(A::AbstractVariable,indices...)
var = nothing
if hasproperty(A,:var)
if hasmethod(SubVariable,Tuple{typeof(A.var),typeof.(indices)...})
var = SubVariable(A.var,indices...)
end
end
T = eltype(A)
N = length(size_getindex(A,indices...))
return SubVariable{T,N,typeof(A),typeof(indices),typeof(A.attrib),typeof(var)}(
A,indices,A.attrib,var)
end
SubVariable(A::AbstractVariable{T,N}) where T where N = SubVariable(A,ntuple(i -> :,N)...)
# recursive calls so that the compiler can infer the types via inline-ing
# and constant propagation
_subsub(indices,i,l) = indices
_subsub(indices,i,l,ip,rest...) = _subsub((indices...,ip[i[l]]),i,l+1,rest...)
_subsub(indices,i,l,ip::Number,rest...) = _subsub((indices...,ip),i,l,rest...)
_subsub(indices,i,l,ip::Colon,rest...) = _subsub((indices...,i[l]),i,l+1,rest...)
#=
j = subsub(parentindices,indices)
Computed the tuple of indices `j` so that
`A[parentindices...][indices...] = A[j...]` for any array `A` and any tuple of
valid indices `parentindices` and `indices`
=#
subsub(parentindices,indices) = _subsub((),indices,1,parentindices...)
materialize(v::SubVariable) = v.parent[v.indices...]
"""
collect always returns an array.
Even if the result of the indexing is a scalar, it is wrapped
into a zero-dimensional array.
"""
function collect(v::SubVariable{T,N}) where T where N
if N == 0
A = Array{T,0}(undef,())
A[] = v.parent[v.indices...]
return A
else
return v.parent[v.indices...]
end
end
Base.Array(v::SubVariable) = collect(v)
function Base.view(v::SubVariable,indices::Union{<:Integer,Colon,AbstractVector{<:Integer}}...)
sub_indices = subsub(v.indices,indices)
SubVariable(parent(v),sub_indices...)
end
"""
sv = view(v::CommonDataModel.AbstractVariable,indices...)
Returns a view of the variable `v` where indices are only lazily applied.
No data is actually copied or loaded.
Modifications to a view `sv`, also modifies the underlying array `v`.
All attributes of `v` are also present in `sv`.
# Examples
```julia
using NCDatasets
fname = tempname()
data = zeros(Int,10,11)
ds = NCDataset(fname,"c")
ncdata = defVar(ds,"temp",data,("lon","lat"))
ncdata_view = view(ncdata,2:3,2:4)
size(ncdata_view)
# output (2,3)
ncdata_view[1,1] = 1
ncdata[2,2]
# outputs 1 as ncdata is also modified
close(ds)
```
"""
Base.view(v::AbstractVariable,indices::Union{<:Integer,Colon,AbstractVector{<:Integer}}...) = SubVariable(v,indices...)
Base.view(v::SubVariable,indices::CartesianIndex) = view(v,indices.I...)
Base.view(v::SubVariable,indices::CartesianIndices) = view(v,indices.indices...)
Base.getindex(v::SubVariable,indices::Union{Int,Colon,AbstractRange{<:Integer}}...) = materialize(view(v,indices...))
Base.getindex(v::SubVariable,indices::CartesianIndex) = getindex(v,indices.I...)
Base.getindex(v::SubVariable,indices::CartesianIndices) =
getindex(v,indices.indices...)
function Base.setindex!(v::SubVariable,data,indices...)
sub_indices = subsub(v.indices,indices)
v.parent[sub_indices...] = data
end
Base.setindex!(v::SubVariable,data,indices::CartesianIndex) =
setindex!(v,data,indices.I...)
Base.setindex!(v::SubVariable,data,indices::CartesianIndices) =
setindex!(v,data,indices.indices...)
dimnames(ds::SubDataset) = dimnames(ds.ds)
defDim(ds::SubDataset,name::SymbolOrString,len) = defDim(ds.ds,name,len)
function dim(ds::SubDataset,dimname::SymbolOrString)
dn = Symbol(dimname)
if hasproperty(ds.indices,dn)
ind = getproperty(ds.indices,dn)
if ind == Colon()
return ds.ds.dim[dimname]
else
return length(ind)
end
else
return ds.ds.dim[dimname]
end
end
unlimited(ds::SubDataset) = unlimited(ds.ds)
function SubDataset(ds::AbstractDataset,indices)
group = OrderedDict((n => SubDataset(g,indices) for (n,g) in ds.group)...)
SubDataset(ds,indices,ds.attrib,group)
end
function Base.view(ds::AbstractDataset; indices...)
SubDataset(ds,values(indices))
end
function Base.getindex(ds::SubDataset,varname::Union{AbstractString, Symbol})
ncvar = ds.ds[varname]
if ndims(ncvar) == 0
return ncvar
end
dims = dimnames(ncvar)
ind = ntuple(i -> get(ds.indices,Symbol(dims[i]),:),ndims(ncvar))
return view(ncvar,ind...)
end
function variable(ds::SubDataset,varname::Union{AbstractString, Symbol})
ncvar = variable(ds.ds,varname)
if ndims(ncvar) == 0
return ncvar
end
dims = dimnames(ncvar)
ind = ntuple(i -> get(ds.indices,Symbol(dims[i]),:),ndims(ncvar))
return view(ncvar,ind...)
end
Base.keys(ds::SubDataset) = keys(ds.ds)
path(ds::SubDataset) = path(ds.ds)
groupname(ds::SubDataset) = groupname(ds.ds)
function dataset(v::SubVariable)
indices = (;((Symbol(d),i) for (d,i) in zip(dimnames(v.parent),v.indices))...)
return SubDataset(dataset(v.parent),indices)
end
function chunking(v::SubVariable)
storage, chunksizes = chunking(v.parent)
return storage, min.(chunksizes,size(v))
end
deflate(v::SubVariable) = deflate(v.parent)
checksum(v::SubVariable) = checksum(v.parent)
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 5637 |
const SymbolOrString = Union{Symbol, AbstractString}
const TIndices = Union{<:Integer,AbstractVector{<:Integer},Colon}
"""
`AbstractDataset` is a collection of multidimensional variables (for example a
NetCDF or GRIB file)
A data set `ds` of a type derived from `AbstractDataset` should implemented at minimum:
* `Base.key(ds)`: return a list of variable names as strings
* `variable(ds,varname::String)`: return an array-like data structure (derived from `AbstractVariable`) of the variables corresponding to `varname`. This array-like data structure should follow the CF semantics.
* `dimnames(ds)`: should be an iterable with all dimension names in the data set `ds`
* `dim(ds,name)`: dimension value corresponding to name
Optionally a data set can have attributes and groups:
* `attribnames(ds)`: should be an iterable with all attribute names
* `attrib(ds,name)`: attribute value corresponding to name
* `groupnames(ds)`: should be an iterable with all group names
* `group(ds,name)`: group corresponding to the name
For a writable dataset, one should also implement:
* `defDim`: define a dimension
* `defAttrib`: define a attribute
* `defVar`: define a variable
* `defGroup`: define a group
"""
abstract type AbstractDataset
end
"""
`AbstractVariable{T,N}` is a subclass of `AbstractArray{T, N}`. A variable `v` of a type derived from `AbstractVariable` should implement:
* `name(v)`: should be the name of variable within the data set
* `dimnames(v)`: should be a iterable data structure with all dimension names of the variable `v`
* `dataset(v)`: the parent dataset containing `v`
* `Base.size(v)`: the size of the variable
* `Base.getindex(v,indices...)`: get the data of `v` at the provided indices
Optionally a variable can have attributes:
* `attribnames(v)`: should be an iterable with all attribute names
* `attrib(v,name)`: attribute value corresponding to name
For a writable dataset, one should also implement:
* `defAttrib`: define a attribute
* `Base.setindex!(v,data,indices...)`: set the data in `v` at the provided indices
"""
abstract type AbstractVariable{T,N} <: AbstractArray{T, N}
end
"""
Variable (with applied transformations following the CF convention)
attrib can have different attributes as the parent variables
(used in GRIBDatasets to map from grib attributes to CF attributes)
"""
struct CFVariable{T,N,TV,TA,TSA} <: AbstractVariable{T, N}
# this var is generally a `Variable` type
var::TV
# Dict-like object for all attributes
attrib::TA
# a named tuple with fill value, scale factor, offset,...
# immutable for type-stability
_storage_attrib::TSA
end
"""
A collection of attributes with a Dict-like interface dispatching to
`attribnames`, `attrib`, `defAttrib` for `keys`, `getindex` and `setindex!`
respectively.
"""
struct Attributes{TDS<:Union{AbstractDataset,AbstractVariable}} <: AbstractDict{SymbolOrString,Any}
ds::TDS
end
"""
A collection of dimensions with a Dict-like interface dispatching to
`dimnames`, `dim`, `defDim` for `keys`, `getindex` and `setindex!`
respectively.
"""
struct Dimensions{TDS<:AbstractDataset} <: AbstractDict{SymbolOrString,Any}
ds::TDS
end
"""
A collection of groups with a Dict-like interface dispatching to
`groupnames` and `group` for `keys` and `getindex` respectively.
"""
struct Groups{TDS<:AbstractDataset} <: AbstractDict{SymbolOrString,Any}
ds::TDS
end
struct CFStdName
name::Symbol
end
# Multi-file related type definitions
struct MFVariable{T,N,M,TA,TDS} <: AbstractVariable{T,N}
ds::TDS
var::CatArrays.CatArray{T,N,M,TA}
dimnames::NTuple{N,String}
varname::String
end
struct MFCFVariable{T,N,M,TA,TV,TDS} <: AbstractVariable{T,N}
ds::TDS
cfvar::CatArrays.CatArray{T,N,M,TA}
var::TV
dimnames::NTuple{N,String}
varname::String
end
struct MFDataset{T,N,S<:AbstractString} <: AbstractDataset where T <: AbstractDataset
ds::Array{T,N}
aggdim::S
isnewdim::Bool
constvars::Vector{Symbol}
_boundsmap::Dict{String,String}
end
# DeferDataset are Dataset which are open only when there are accessed and
# closed directly after. This is necessary to work with a large number
# of files (e.g. more than 1000).
struct Resource
filename::String
mode::String
metadata::OrderedDict
end
struct DeferDataset{TDS} <: AbstractDataset
r::Resource
groupname::String
data::OrderedDict
_boundsmap::Dict{String,String}
end
struct DeferVariable{T,N,TDS} <: AbstractVariable{T,N}
r::Resource
varname::String
data::OrderedDict
end
# view of subsets
struct SubVariable{T,N,TA,TI,TAttrib,TV} <: AbstractVariable{T,N}
parent::TA
indices::TI
attrib::TAttrib
# unpacked variable
var::TV
end
struct SubDataset{TD,TI,TA,TG} <: AbstractDataset
ds::TD
indices::TI
attrib::TA
group::TG
end
const Iterable = Union{Attributes,Dimensions,Groups,AbstractDataset}
# memory dataset
mutable struct ResizableArray{T,N} <: AbstractArray{T,N}
A::AbstractArray{T,N}
fillvalue::T
end
struct MemoryVariable{T,N,TP,TA <: AbstractArray{T,N}} <: AbstractVariable{T,N}
parent_dataset::TP
name::String
dimnames::NTuple{N,String}
data::TA
_attrib::OrderedDict{String,Any}
end
struct MemoryDataset{TP <: Union{Nothing,AbstractDataset},Tmasingvalue} <: AbstractDataset
parent_dataset::TP
name::String # "/" for root group
dimensions::OrderedDict{String,Int}
variables::OrderedDict{String,MemoryVariable}
_attrib::OrderedDict{String,Any}
unlimited::Vector{String}
_group::OrderedDict{String,Any}
maskingvalue::Tmasingvalue
end
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 10446 | """
CommonDataModel.name(v::AbstractVariable)
Return the name of the variable `v` as a string.
"""
name(v::AbstractVariable) = ""
"""
CommonDataModel.dimnames(v::AbstractVariable)
Return an iterable of the dimension names of the variable `v`.
"""
dimnames(av::AbstractVariable) = ()
"""
CommonDataModel.varnames(ds::AbstractDataset)
Return an iterable of all the variable name.
"""
varnames(ds::AbstractDataset) = ()
"""
CommonDataModel.variable(ds::AbstractDataset,variablename::SymbolOrString)
Return the variable with the name `variablename` from the data set `ds`.
"""
function variable(ds::AbstractDataset,variablename::SymbolOrString)
error("no variable $variablename in $(path(ds)) (abstract method)")
end
function defVar(ds::AbstractDataset,name::SymbolOrString,type::DataType,
dimnames)
error("unimplemented for abstract type")
end
"""
fillvalue(::Type{Int8})
fillvalue(::Type{UInt8})
fillvalue(::Type{Int16})
fillvalue(::Type{UInt16})
fillvalue(::Type{Int32})
fillvalue(::Type{UInt32})
fillvalue(::Type{Int64})
fillvalue(::Type{UInt64})
fillvalue(::Type{Float32})
fillvalue(::Type{Float64})
fillvalue(::Type{Char})
fillvalue(::Type{String})
Default fill-value for the given type from NetCDF.
"""
@inline fillvalue(::Type{Int8}) = Int8(-127)
@inline fillvalue(::Type{UInt8}) = UInt8(255)
@inline fillvalue(::Type{Int16}) = Int16(-32767)
@inline fillvalue(::Type{UInt16}) = UInt16(65535)
@inline fillvalue(::Type{Int32}) = Int32(-2147483647)
@inline fillvalue(::Type{UInt32}) = UInt32(4294967295)
@inline fillvalue(::Type{Int64}) = Int64(-9223372036854775806)
@inline fillvalue(::Type{UInt64}) = UInt64(18446744073709551614)
@inline fillvalue(::Type{Float32}) = 9.9692099683868690f+36
@inline fillvalue(::Type{Float64}) = 9.9692099683868690e+36
@inline fillvalue(::Type{Char}) = '\0'
@inline fillvalue(::Type{String}) = ""
# based on:
# https://github.com/JuliaLang/julia/blob/94fd312df03d5075796fbd2e8b47288a84a1c6de/base/promotion.jl#L141
# MIT
# typesplit(Union{Float64,Missing},Missing) == Float64
function typesplit(@nospecialize(TS), @nospecialize(T))
if TS <: T
return Union{}
end
if isa(TS, Union)
return Union{typesplit(TS.a, T),
typesplit(TS.b, T)}
end
return TS
end
# convert e.g. Union{Float64,Missing} to Float64
# similar to Base.nonmissingtype
function nonuniontype(T,TS)
if typeof(TS) == Union
return typesplit(TS, T)
else
TS
end
end
function defVar(ds::AbstractDataset,
name::SymbolOrString,
data::AbstractArray{T,N},
dimnames;
kwargs...) where {T,N}
Tmaskingvalue = typeof(maskingvalue(ds))
# convert e.g. Union{Float64,Missing} or Union{Float64,Nothing} to Float64
nctype = nonuniontype(Tmaskingvalue,T)
_defVar(ds,name,data,nctype,dimnames; kwargs...)
end
# defining a scalar
function defVar(ds::AbstractDataset,name::SymbolOrString,data,dimnames; kwargs...)
# eltype of a String would be Char
if data isa String
nctype = String
else
nctype = eltype(data)
end
_defVar(ds,name,data,nctype,dimnames; kwargs...)
end
as_dict(x::NamedTuple) = OrderedDict(zip(keys(x),values(x)))
as_dict(x) = OrderedDict(x)
function _defVar(ds::AbstractDataset,name::SymbolOrString,data,::Type{<:Union{DateTime,AbstractCFDateTime}},vardimnames; kwargs...)
_defVar(ds,name,data,Float64,vardimnames; kwargs...)
end
function _defVar(ds::AbstractDataset,name::SymbolOrString,data,nctype,vardimnames; attrib = [], kwargs...)
# define the dimensions if necessary
for (i,dimname) in enumerate(String.(vardimnames))
if !(dimname in dimnames(ds))
@debug "define dimension" dimname dimnames(ds)
defDim(ds,dimname,size(data,i))
elseif !(dimname in unlimited(ds))
dimlen = dim(ds,dimname)
if (dimlen != size(data,i))
error("dimension $(dimname) is already defined with the " *
"length $dimlen. It cannot be redefined with a length of $(size(data,i)) for the variable $name.")
end
end
end
T = eltype(data)
Tmaskingvalue = typeof(maskingvalue(ds))
# we should preserve the order
# value type is promoted to Any as we add values of different type
attrib = convert(OrderedDict{SymbolOrString,Any},as_dict(attrib))
Tnonunion = nonuniontype(Tmaskingvalue,T)
if Tnonunion <: TimeType
if !haskey(attrib,"units")
push!(attrib,"units" => CFTime.DEFAULT_TIME_UNITS)
end
if !haskey(attrib,"calendar")
# these dates cannot be converted to the standard calendar
if T <: Union{DateTime360Day,Tmaskingvalue}
push!(attrib,"calendar" => "360_day")
elseif T <: Union{DateTimeNoLeap,Tmaskingvalue}
push!(attrib,"calendar" => "365_day")
elseif T <: Union{DateTimeAllLeap,Tmaskingvalue}
push!(attrib,"calendar" => "366_day")
end
end
end
maskingvalue_nan = maskingvalue(ds) isa Number && isnan(maskingvalue(ds))
# make sure a fill value is set if we deduce from the type of data
# that it is needed
if (Tmaskingvalue <: T) && !haskey(attrib,"_FillValue") &&
!haskey(kwargs,:fillvalue) && !maskingvalue_nan
push!(attrib,"_FillValue" => fillvalue(nctype))
end
v = defVar(ds,name,nctype,vardimnames;
attrib = attrib,
kwargs...)
# "v[:] = data" does not work with DiskArrays and unlimited dimensions
if data isa String
# axes of a scalar String fails (while ok for Number and Char)
v[] = data
else
v[axes(data)...] = data
end
return v
end
# dimension names can be ommited for scalars
function defVar(ds::AbstractDataset,name,data::T; kwargs...) where T <: Union{Number,String,Char}
v = defVar(ds,name,T,(); kwargs...)
v[] = data
return v
end
"""
v = CommonDataModel.defVar(ds::AbstractDataset,src::AbstractVariable)
v = CommonDataModel.defVar(ds::AbstractDataset,name::SymbolOrString,src::AbstractVariable)
Defines and return the variable in the data set `ds`
copied from the variable `src`. The dimension name, attributes
and data are copied from `src` as well as the variable name (unless provide by `name`).
"""
function defVar(dest::AbstractDataset,varname::SymbolOrString,srcvar::AbstractVariable; kwargs...)
_ignore_checksum = false
if haskey(kwargs,:checksum)
_ignore_checksum = kwargs[:checksum] === nothing
end
src = dataset(srcvar)
# dimensions
unlimited_dims = unlimited(src)
for dimname in dimnames(srcvar)
if dimname in _dimnames_recursive(dest)
# dimension is already defined
continue
end
if dimname in unlimited_dims
defDim(dest, dimname, Inf)
else
defDim(dest, dimname, dim(src,dimname))
end
end
var = srcvar.var
dimension_names = dimnames(var)
cfdestvar = defVar(dest, varname, eltype(var), dimension_names;
attrib = attribs(srcvar))
destvar = variable(dest,varname)
storage,chunksizes = chunking(var)
@debug "chunking " name(var) size(var) size(cfdestvar) storage chunksizes
chunking(cfdestvar,storage,chunksizes)
isshuffled,isdeflated,deflate_level = deflate(var)
@debug "compression" isshuffled isdeflated deflate_level
deflate(cfdestvar,isshuffled,isdeflated,deflate_level)
if !_ignore_checksum
checksummethod = checksum(var)
@debug "check-sum" checksummethod
checksum(cfdestvar,checksummethod)
end
# copy data
# TODO use DiskArrays.eachchunk
# if hasmethod(eachchunk,Tuple{typeof(var)})
# for indices in eachchunk(var)
# destvar[indices...] = var[indices...]
# end
# else
indices = ntuple(i -> axes(var,i),ndims(var))
destvar[indices...] = var[indices...]
#end
return cfdestvar
end
function defVar(dest::AbstractDataset,srcvar::AbstractVariable; kwargs...)
defVar(dest,name(srcvar),srcvar; kwargs...)
end
"""
ds = CommonDataModel.dataset(v::AbstractVariable)
Return the data set `ds` to which a the variable `v` belongs to.
"""
function dataset(v::AbstractVariable)
error("unimplemented for abstract type")
end
function Base.show(io::IO,v::AbstractVariable)
level = get(io, :level, 0)
indent = " " ^ get(io, :level, 0)
delim = " × "
try
dims = dimnames(v)
sz = size(v)
printstyled(io, indent, name(v),color=variable_color[])
if length(sz) > 0
print(io,indent," (",join(sz,delim),")\n")
print(io,indent," Datatype: ")
printstyled(io,eltype(v),bold=true)
if v isa CFVariable
print(io," (",eltype(v.var),")")
end
print(io,"\n")
print(io,indent," Dimensions: ",join(dims,delim),"\n")
else
print(io,indent,"\n")
end
if length(v.attrib) > 0
print(io,indent," Attributes:\n")
show_attrib(IOContext(io,:level=>level+3),attribs(v))
end
catch err
@debug "error in show" err
print(io,"Variable (dataset closed)")
end
end
chunking(v::AbstractVariable) = (:contiguous,size(v))
chunking(v::AbstractVariable,storage,chunksizes) = nothing
deflate(v::AbstractVariable) = (false,false,0)
deflate(v::AbstractVariable,isshuffled,isdeflated,deflate_level) = nothing
checksum(v::AbstractVariable) = :nochecksum
checksum(v::AbstractVariable,checksummethod) = nothing
fillvalue(v::AbstractVariable{T}) where T = v.attrib["_FillValue"]::T
# computes the shape of the array of size `sz` after applying the indexes
# size(a[indexes...]) == _shape_after_slice(size(a),indexes...)
# the difficulty here is to make the size inferrable by the compiler
@inline _shape_after_slice(sz,indexes...) = __sh(sz,(),1,indexes...)
@inline __sh(sz,sh,n,i::Integer,indexes...) = __sh(sz,sh, n+1,indexes...)
@inline __sh(sz,sh,n,i::Colon, indexes...) = __sh(sz,(sh...,sz[n]), n+1,indexes...)
@inline __sh(sz,sh,n,i, indexes...) = __sh(sz,(sh...,length(i)),n+1,indexes...)
@inline __sh(sz,sh,n) = sh
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 815 | using CommonDataModel
using CommonDataModel: MemoryDataset
using Test
@testset "CommonDataModel" begin
#include("test_conversion.jl")
include("test_empty.jl")
include("test_scaling.jl")
include("test_variable.jl")
include("test_attrib.jl")
include("test_copy.jl")
end
@testset "CF conventions" begin
include("test_cfconventions.jl")
include("test_coord.jl")
include("test_bounds.jl")
end
@testset "Multi-file" begin
include("test_multifile.jl")
end
@testset "views" begin
include("test_subvariable.jl")
end
@testset "@select macro" begin
include("test_select.jl")
include("test_multifile_select.jl")
end
@testset "groupby" begin
include("test_groupby.jl")
include("test_rolling.jl")
end
@testset "aqua checks" begin
include("test_aqua.jl")
end
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 65 | using Aqua
using CommonDataModel
Aqua.test_all(CommonDataModel)
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 3364 | using DataStructures
using Test
sz = (4,5)
filename = tempname()
#filename = "/tmp/mytest.nc"
#TDS = NCDatasets.NCDataset
TDS = MemoryDataset
TDS(filename,"c") do ds
ds.dim["lon"] = sz[1]
ds.dim["lat"] = sz[2]
v = defVar(ds,"temperature",Float32,("lon","lat"),
attrib = ["long_name" => "Temperature",
"test_vector_attrib" => [1,2,3]])
# write attributes
v.attrib["units"] = "degree Celsius"
v.attrib["comment"] = "this is a string attribute with unicode Ω ∈ ∑ ∫ f(x) dx "
# check presence of attribute
@test haskey(v.attrib,"comment")
@test v.attrib["long_name"] == "Temperature"
@test v.attrib[:long_name] == "Temperature"
@test v.attrib["test_vector_attrib"] == [1,2,3]
@test v.attrib["comment"] == "this is a string attribute with unicode Ω ∈ ∑ ∫ f(x) dx "
@test get(v.attrib,"does-not-exist","default") == "default"
@test get(v.attrib,"units","default") == "degree Celsius"
# test deletion of attributes
v.attrib["todelete"] = "foobar"
@test haskey(v.attrib,"todelete")
delete!(v.attrib,"todelete")
@test !haskey(v.attrib,"todelete")
for T in [UInt8,Int8,UInt16,Int16,UInt32,Int32,UInt64,Int64,Float32,Float64,
String,Char]
# scalar attribute
name = "scalar-attrib-$T"
refdata =
if T == Char
'a'
elseif T == String
"abc"
else
123
end
v.attrib[name] = T(refdata)
attval = v.attrib[name]
@test typeof(attval) == T
@test attval == refdata
# vector attribute
name = "vector-attrib-$T"
refvecdata =
if T == Char
['a','b']
elseif T == String
["abc","xyz"]
else
[1,2,3,4]
end
attval = T.(refvecdata)
attval = attval
@test eltype(attval) == T
@test attval == refvecdata
end
# symbols in the attrib dict
foo = defVar(ds,"foovar",Int64,("lon","lat"),
attrib = [:long_name => "foo variable"])
@test foo.attrib["long_name"] == "foo variable"
end
filename = tempname()
TDS(filename,"c") do ds
# test deletion of attributes
ds.attrib["todelete"] = "foobar"
end
TDS(filename,"a") do ds
@test haskey(ds.attrib,"todelete")
delete!(ds.attrib,"todelete")
@test !haskey(ds.attrib,"todelete")
end
# NCDatasets issue #241
filename = tempname()
ds = TDS(filename,"c")
data = randn(4,5)
defVar(ds,"temperature",data,("lon","lat"),
attrib = OrderedDict(:long_name => "Temperature",
:test_vector_attrib => [1,2,3]))
defVar(ds,:temperature2,data,(:lon,:lat),
attrib = OrderedDict(:long_name => "Temperature",
:test_vector_attrib => [1,2,3]))
defVar(ds,:temperature3,data,(:lon,:lat),
attrib = Dict(:long_name => "Temperature",
:test_vector_attrib => [1,2,3]))
defVar(ds,:temperature4,data,(:lon,:lat),
attrib = (long_name = "Temperature",
test_vector_attrib = [1,2,3]))
for (vn,var) in ds
@test startswith(vn,"temperature")
@test var.attrib["long_name"] == "Temperature"
@test var.attrib["test_vector_attrib"] == [1,2,3]
end
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 1550 | using CommonDataModel: bounds
using Test
using DataStructures
using Dates
#TDS = NCDataset
TDS = MemoryDataset
time = DateTime(2000,1,2):Dates.Day(1):DateTime(2000,1,4)
time_bounds = Matrix{DateTime}(undef,2,length(time))
time_bounds[1,:] = time .- Dates.Hour(12)
time_bounds[2,:] = time .+ Dates.Hour(12)
fname = tempname()
ds = TDS(fname,"c")
ds.dim["nv"] = 2;
ds.dim["time"] = length(time);
nctime = defVar(ds, "time", Float64, ("time",),attrib=OrderedDict(
"units" => "days since 2000-01-01",
"scale_factor" => 10.,
"bounds" => "time_bounds"));
nctime_bounds = defVar(ds, "time_bounds", Float64, ("nv","time"),attrib=OrderedDict())
nctime[:] = time
nctime_bounds = bounds(nctime)
nctime_bounds[:,:] = time_bounds
@test nctime_bounds.var[:,:] ≈ [0.5 1.5 2.5;
1.5 2.5 3.5]
@test nctime_bounds[:,:] == time_bounds
close(ds)
# NCDatasets issue 170
fname = tempname()
ds = TDS(fname,"c")
ds.dim["time"] = 3
ds.dim["bnds"] = 2
nctime = defVar(ds,"time", Float64, ("time",), attrib = OrderedDict(
"standard_name" => "time",
"long_name" => "time",
"units" => "days since 2001-1-1",
"bounds" => "time_bnds",
))
nctime_bnds = defVar(ds,"time_bnds", Float64, ("bnds", "time"))
nctos = defVar(ds,"tos", Float32, ("time",), attrib = OrderedDict(
"_FillValue" => Float32(1.0e20),
))
nctos[:] = zeros(Float32,3)
close(ds)
ds = TDS(fname)
tos = ds["tos"][:]
@test all(tos .== zeros(3))
close(ds)
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 5225 | using Test
using DataStructures
using CommonDataModel: ancillaryvariables, filter, @CF_str
fname = tempname()
#import NCDatasets
#TDS = NCDatasets.NCDataset
TDS = MemoryDataset
ds = TDS(fname,"c")
# Dimensions
ds.dim["time"] = 3
# Declare variables
ncLAT = defVar(ds,"LAT", Float64, ("time",), attrib = [
"standard_name" => "latitude",
"long_name" => "Latitude coordiante",
"units" => "degree_north",
"ancillary_variables" => "QC_LAT",
"axis" => "Y",
])
ncQC_LAT = defVar(ds,"QC_LAT", Int8, ("time",), attrib = [
"standard_name" => "latitude status_flag",
"long_name" => "Quality flag for latitude",
"_FillValue" => Int8(10),
"flag_values" => Int8[0, 1, 2, 3, 4, 6, 9],
"flag_meanings" => "no_qc_performed good_data probably_good_data probably_bad_data bad_data spike missing_value",
])
ncDEPTH = defVar(ds,"DEPTH", Float64, (), attrib = [
"standard_name" => "depth",
"long_name" => "Depth coordinate",
"units" => "m",
"positive" => "down",
"axis" => "Z",
"reference_datum" => "geographical coordinates, WGS84 projection",
])
ncLAT[:] = [1.,2.,3.]
ncQC_LAT[:] = [1,1,4]
close(ds)
ds = TDS(fname,"r")
@test name(ancillaryvariables(ds["LAT"],"status_flag")) == "QC_LAT"
@test isequal(filter(ds["LAT"],:,accepted_status_flags = ["good_data","probably_good_data"]),
[1.,2.,missing])
@test ancillaryvariables(ds["DEPTH"],"status_flag") == nothing
@test_throws ErrorException filter(ds["DEPTH"],:,accepted_status_flags = ["good_data","probably_good_data"])
close(ds)
# query by CF Standard Name
fname = tempname()
ds = TDS(fname,"c", attrib = OrderedDict(
"title" => "title",
));
# Dimensions
ds.dim["lon"] = 10
ds.dim["lat"] = 11
# Declare variables
nclon = defVar(ds,"lon", Float64, ("lon",), attrib = OrderedDict(
"long_name" => "Longitude",
"standard_name" => "longitude",
"units" => "degrees_east",
))
nclat = defVar(ds,"lat", Float64, ("lat",), attrib = OrderedDict(
"long_name" => "Latitude",
"standard_name" => "latitude",
"units" => "degrees_north",
))
ncvar = defVar(ds,"bat", Float32, ("lon", "lat"), attrib = OrderedDict(
"long_name" => "elevation above sea level",
"standard_name" => "height",
"units" => "meters",
"_FillValue" => Float32(9.96921e36),
))
ncvar1 = defVar(ds,"temp1", Float32, ("lon", "lat"), attrib = OrderedDict(
"standard_name" => "temperature",
"units" => "degree Celsius",
"_FillValue" => Float32(9.96921e36),
))
ncvar2 = defVar(ds,"temp2", Float32, ("lon", "lat"), attrib = OrderedDict(
"standard_name" => "temperature",
"units" => "degree Celsius",
"_FillValue" => Float32(9.96921e36),
))
# Define variables
data = rand(Float32,10,11)
nclon[:] = 1:10
nclat[:] = 1:11
ncvar[:,:] = data
height = ds[CF"height"]
@test height[:,:] == data
@test height[CF"longitude"][:] == 1:10
@test height[CF"latitude"][:] == 1:11
height = @view ds[CF"height"][2:3,2:3]
@test height[:,:] == data[2:3,2:3]
@test height[CF"longitude"][:] == 2:3
@test height[CF"latitude"][:] == 2:3
@test_throws KeyError ds[CF"temperature"]
#=
using Plots
function myplot(height::AbstractVariable)
heatmap(
height[CF"longitude"][:],
height[CF"latitude"][:],
height[:,:])
end
myplot(height)
=#
fname = tempname()
ds = TDS(fname,"c")
ds.dim["xi_u"] = 137
ds.dim["xi_v"] = 138
ds.dim["eta_u"] = 75
ds.dim["eta_v"] = 74
ds.dim["ocean_time"] = Inf # unlimited dimension
nclon_u = defVar(ds,"lon_u", Float64, ("xi_u", "eta_u"), attrib = OrderedDict(
"standard_name" => "longitude",
))
nclat_u = defVar(ds,"lat_u", Float64, ("xi_u", "eta_u"), attrib = OrderedDict(
"standard_name" => "latitude",
))
nclon_v = defVar(ds,"lon_v", Float64, ("xi_v", "eta_v"), attrib = OrderedDict(
"standard_name" => "longitude",
))
nclat_v = defVar(ds,"lat_v", Float64, ("xi_v", "eta_v"), attrib = OrderedDict(
"standard_name" => "latitude",
))
ncubar = defVar(ds,"ubar", Float32, ("xi_u", "eta_u", "ocean_time"), attrib = OrderedDict(
"standard_name" => "barotropic_sea_water_x_velocity",
))
ncvbar = defVar(ds,"vbar", Float32, ("xi_v", "eta_v", "ocean_time"), attrib = OrderedDict(
"standard_name" => "barotropic_sea_water_y_velocity",
))
close(ds)
ds = TDS(fname)
# This produces an error because it is unclear if we should load lon_u or lon_v
@test_throws KeyError ds[CF"longitude"] # error
nclon_u2 = ds["ubar"][CF"longitude"]
@test name(nclon_u2) == "lon_u"
nclon_u2 = ds["ubar"]["lon_u"]
@test name(nclon_u2) == "lon_u"
nclon_u2 = ds["ubar"][:lon_u]
@test name(nclon_u2) == "lon_u"
@test string(CF"longitude") == "longitude"
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 1244 | import NCDatasets
import GRIBDatasets
import CommonDataModel as CDM
using Test
using DataStructures
datadir = joinpath(dirname(pathof(GRIBDatasets)),"..","test","sample-data")
filename = joinpath(datadir,"era5-levels-members.grib")
ds = GRIBDatasets.Dataset(filename)
io = IOBuffer()
show(io,ds)
out = String(take!(io))
@test occursin("Global attributes",out)
@test occursin("CF-",out)
# dimension
@test CDM.dims(ds)["lon"] == 120
@test CDM.dim(ds,"lon") == 120
@test "lon" in CDM.dimnames(ds)
tmp_filename = tempname()
NCDatasets.write(tmp_filename,ds)
@test isfile(tmp_filename)
dsnc = NCDatasets.Dataset(tmp_filename)
@test ds["number"][:] == dsnc["number"][:]
@test OrderedDict(CDM.dims(ds)) == OrderedDict(CDM.dims(dsnc))
@test OrderedDict(CDM.attribs(ds)) == OrderedDict(CDM.attribs(dsnc))
@test OrderedDict(CDM.groups(ds)) == OrderedDict(CDM.groups(dsnc))
close(dsnc)
# copy individual variables
tmp_filename = tempname()
dsnc = NCDatasets.Dataset(tmp_filename,"c")
gribv = ds["lon"]
ncv = CDM.defVar(dsnc,gribv)
@test CDM.name(ncv) == CDM.name(gribv)
@test ncv[:] == gribv[:]
@test CDM.attrib(ncv,"units") == CDM.attrib(gribv,"units")
@test collect(CDM.dimnames(ncv)) == collect(CDM.dimnames(gribv))
close(dsnc)
close(ds)
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 2697 | using Test
using CommonDataModel: coord
fname = tempname()
#TDS = NCDataset
TDS = MemoryDataset
for define_standard_name in [false,true]
TDS(fname,"c") do ds
# Dimensions
ds.dim["xi_rho"] = 6
ds.dim["xi_u"] = 5
ds.dim["xi_v"] = 6
ds.dim["xi_psi"] = 5
ds.dim["eta_rho"] = 6
ds.dim["eta_u"] = 6
ds.dim["eta_v"] = 5
ds.dim["eta_psi"] = 5
ds.dim["N"] = 30
ds.dim["s_rho"] = 30
ds.dim["s_w"] = 31
ds.dim["tracer"] = 63
ds.dim["ocean_time"] = Inf # unlimited dimension
# Declare variables
nclon_rho = defVar(ds,"lon_rho", Float64, ("xi_rho", "eta_rho"))
nclon_rho.attrib["long_name"] = "longitude of RHO-points"
nclon_rho.attrib["units"] = "degree_east"
nclon_rho.attrib["field"] = "lon_rho, scalar"
if define_standard_name
nclon_rho.attrib["standard_name"] = "longitude"
end
nclat_rho = defVar(ds,"lat_rho", Float64, ("xi_rho", "eta_rho"))
nclat_rho.attrib["long_name"] = "latitude of RHO-points"
nclat_rho.attrib["units"] = "degree_north"
nclat_rho.attrib["field"] = "lat_rho, scalar"
if define_standard_name
nclon_rho.attrib["standard_name"] = "latitude"
end
nclon_u = defVar(ds,"lon_u", Float64, ("xi_u", "eta_u"))
nclon_u.attrib["long_name"] = "longitude of U-points"
nclon_u.attrib["units"] = "degree_east"
nclon_u.attrib["field"] = "lon_u, scalar"
nclat_u = defVar(ds,"lat_u", Float64, ("xi_u", "eta_u"))
nclat_u.attrib["long_name"] = "latitude of U-points"
nclat_u.attrib["units"] = "degree_north"
nclat_u.attrib["field"] = "lat_u, scalar"
nczeta = defVar(ds,"zeta", Float32, ("xi_rho", "eta_rho", "ocean_time"))
nczeta.attrib["long_name"] = "free-surface"
nczeta.attrib["units"] = "meter"
nczeta.attrib["time"] = "ocean_time"
nczeta.attrib["coordinates"] = "lat_rho lon_rho"
nczeta.attrib["field"] = "free-surface, scalar, series"
ncubar = defVar(ds,"ubar", Float32, ("xi_u", "eta_u", "ocean_time"))
ncubar.attrib["long_name"] = "vertically integrated u-momentum component"
ncubar.attrib["units"] = "meter second-1"
ncubar.attrib["time"] = "ocean_time"
ncubar.attrib["coordinates"] = "lat_u lon_u"
ncubar.attrib["field"] = "ubar-velocity, scalar, series"
end
local ds
ds = TDS(fname)
@test name(coord(ds["zeta"],"longitude")) == "lon_rho"
@test name(coord(ds["ubar"],"longitude")) == "lon_u"
@test coord(ds["ubar"],"foobar") == nothing
close(ds)
end
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 530 | using Test
using Dates
using Printf
using DataStructures
using CFTime
sz = (4,5)
filename = tempname()
#TDS = NCDatasets.NCDataset
TDS = MemoryDataset
ds = TDS(filename,"c")
data = rand(1:10,sz)
v = defVar(ds,"data",data,("lon","lat"))
filename2 = tempname()
ds2 = TDS(filename2,"c")
ds2["new_data"] = ds["data"]
@test ds2["new_data"][:,:] == ds["data"][:,:]
close(ds2)
filename2 = tempname()
ds2 = TDS(filename2,"c")
ds2["new_data"] = view(ds["data"],1:2,1:2)
@test ds2["new_data"][:,:] == ds["data"][1:2,1:2]
close(ds2)
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 866 | import CommonDataModel as CDM
struct DummyEmptyDataset <: CDM.AbstractDataset
end
dd = DummyEmptyDataset();
@test CDM.dimnames(dd) == ()
@test_throws Exception CDM.dim(dd,"does_not_exist")
@test_throws Exception CDM.defDim(dd,"does_not_exist",1)
@test CDM.attribnames(dd) == ()
@test_throws Exception CDM.attrib(dd,"does_not_exist")
@test_throws Exception CDM.defAttrib(dd,"does_not_exist",1)
@test CDM.varnames(dd) == ()
@test_throws Exception CDM.variable(dd,"does_not_exist")
@test_throws Exception CDM.defVar(dd,"does_not_exist",Int32,())
@test CDM.path(dd) == ""
@test CDM.groupnames(dd) == ()
# not available in julia 1.6
#@test_throws "no group" CDM.group(dd,"does_not_exist")
#@test_throws "unimplemented" CDM.defGroup(dd,"does_not_exist")
@test_throws Exception CDM.group(dd,"does_not_exist")
@test_throws Exception CDM.defGroup(dd,"does_not_exist")
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 6412 | using Test
using Dates
#using NCDatasets
using Statistics
using CommonDataModel
using CommonDataModel:
@groupby,
GroupedVariable,
MemoryDataset,
ReducedGroupedVariable,
_array_selectdim_indices,
_dest_indices,
_dim_after_getindex,
_indices,
dataset,
defVar,
groupby,
name,
variable
#include("memory_dataset.jl");
#TDS = NCDatasets.NCDataset
TDS = MemoryDataset
# test helper functions
@test _dest_indices(1,1,(:,:,:)) == (1,:,:)
@test _dest_indices(2,1,(:,:,:)) == (:,1,:)
@test _dest_indices(3,1,(:,:,:)) == (:,:,1)
@test _dest_indices(3,1,(1,:,:)) == (:,1)
@test _indices(1,12,1,(:,:,:)) == (12,1,1)
@test _indices(2,12,1,(:,:,:)) == (1,12,1)
@test _indices(2,12,1,(1,:,:)) == (12,1)
@test _indices(1,12,:,(:,:,:)) == (12,:,:)
@test _indices(1,1,:,(:,:,:)) == (1,:,:)
@test _array_selectdim_indices((),3,1:1,2,2,3) == (:,:,1:1)
@test _dim_after_getindex(0,:,:,:) == 3
@test _dim_after_getindex(0,1,1,1) == 0
@test _dim_after_getindex(0,:,1,:) == 2
@test _dim_after_getindex(0,[1,2],1,:) == 2
time = DateTime(2000,1,1):Day(10):DateTime(2012,1,1);
data = rand(Float32.(-9:99),10,11,length(time))
varname = "data"
fname = tempname()
data3 = Array{Union{Missing,Float32},3}(undef,size(data))
data3 .= data
data3[1,1,:] .= missing
data3[1,2,1] = missing
TDS(fname,"c",attrib = ["title" => "test"]) do ds
defVar(ds,"lon",1:size(data,1),("lon",))
defVar(ds,"lat",1:size(data,2),("lat",))
defVar(ds,"time",time,("time",))
defVar(ds,"data",data,("lon","lat","time"),attrib = ["foo" => "bar"])
defVar(ds,"data2",data .+ 1,("lon","lat","time"))
defVar(ds,"data3",data3,("lon","lat","time"))
defVar(ds,"data4",data,("lon","lat","time"),attrib = ["scale_factor" => 2])
end
ds = TDS(fname)
coordname = "time"
group_fun = time -> Dates.Month(time)
v = ds[varname]
for reduce_fun in (sum,mean,var,std,median,maximum)
local data_by_class
data_by_class_ref = cat(
[reduce_fun(v[:,:,findall(Dates.month.(ds[coordname][:]) .== m)],dims=3)
for m in 1:12]...,dims=3)
for indices = [
(:,:,:),
(1:3,2:5,:),
(1:3,2,:),
(2,1:3,:),
(1:3,2:6,2:6),
(:,:,2),
]
#@show reduce_fun,indices
local data_by_class
data_by_class = reduce_fun(groupby(ds[varname],:time => Dates.Month))[indices...]
@test data_by_class ≈ data_by_class_ref[indices...]
@test size(data_by_class) == size(data_by_class_ref[indices...])
end
end
# sum of absolute values
sum_abs = cat([sum(abs.(ds[varname][:,:,:][:,:,findall(Dates.month.(ds[coordname][:]) .== m)]),dims=3)
for m in 1:12]...,dims=3)
gv = groupby(ds[varname],:time => Dates.Month)
absp(x) = abs.(x)
gd = groupby(ds[:data],:time => Dates.Month);
@test sum(absp.(gd))[:,:,:] == sum_abs
d_sum = cat([sum(ds[varname][:,:,:][:,:,findall(Dates.month.(ds[coordname][:]) .== m)],dims=3)
for m in 1:12]...,dims=3)
d_mean = cat([mean(ds[varname][:,:,:][:,:,findall(Dates.month.(ds[coordname][:]) .== m)],dims=3)
for m in 1:12]...,dims=3)
gd = groupby(ds["data"],"time" => Dates.Month)
month_sum = sum(gd);
@test month_sum[:,:,:] == d_sum
gd = groupby(ds[:data],:time => Dates.Month)
month_sum = sum(gd);
@test month_sum[:,:,:] == d_sum
# group dataset function
gds = mean(groupby(ds,:time => Dates.Month))
@test gds["data"][:,:,:] == d_mean
@test gds["lon"][:] == ds["lon"][:]
@test gds["lat"][:] == ds["lat"][:]
@test gds["data4"][:,:,:] == d_mean
@test gds.attrib["title"] == "test"
@test gds["data"].attrib["foo"] == "bar"
@test collect(keys(gds.attrib)) == ["title"]
@test collect(keys(gds["data"].attrib)) == ["foo"]
# group dataset macro
gds = mean(@groupby(ds,Dates.Month(time)))
@test gds["data"][:,:,:] == d_mean
@test gds["lon"][:] == ds["lon"][:]
@test gds["lat"][:] == ds["lat"][:]
gr = mean(groupby(ds["data4"],:time => Dates.Month))
@test gr[:,:,:] == d_mean
gr = month_sum
f = gr.reduce_fun
mysum(x; dims=nothing) = sum(x,dims=dims)
mysum(gv::GroupedVariable) = reduce(mysum,gv)
gd = groupby(ds[:data],:time => Dates.Month);
month_sum = mysum(gd);
@test month_sum[:,:,:] == d_sum
month_sum = reduce(mysum,gd);
@test month_sum[:,:,:] == d_sum
# test macro
gd = @groupby(v,Dates.Month(time));
@test ndims(gd) == 1
@test size(gd) == (12,)
gr = sum(gd)
@test ndims(gr) == 3
@test size(gr) == (10,11,12)
@test sum(absp.(gd))[:,:,:] == sum_abs
gm = sum(gd);
@test gm[:,:,:] == d_sum
fun_call_groupby(v) = sum(@groupby(v,Dates.Month(time)));
gm = fun_call_groupby(v)
@test gm[:,:,:] == d_sum
gm = mean(@groupby(v,time >= DateTime(2001,1,1)));
gm2 = mean(v[:,:,findall(v["time"][:] .>= DateTime(2001,1,1))],dims=3)
@test gm[:,:,:][:,:,2] ≈ gm2
@test gm[:,:,2:2] ≈ gm2[:,:,1:1]
@test gm[:,:,2] ≈ gm2
gm = @groupby(v,time >= DateTime(2001,1,1)) |> mean |> Array
@test gm[:,:,2] ≈ gm2
# broadcast of mean
C = v .- mean(@groupby(v,Dates.Month(time)));
B = Array(mean(@groupby(v,Dates.Month(time))))
Cref = similar(v)
classes = Dates.Month.(v["time"][:])
unique_class = unique(classes)
for k = 1:length(unique_class)
local indices
indices = findall(==(unique_class[k]),classes)
Cref[:,:,indices] = v[:,:,indices] .- B[:,:,k:k]
end
@test C ≈ Cref
Cn = mean(@groupby(v,Dates.Month(time))) .- v
@test Cn ≈ -Cref
# parent dataset
gr = mean(@groupby(v,Dates.Month(time)))
gds = dataset(gr);
@test Set(keys(gds)) == Set(keys(ds))
@test variable(gds,"data")[:,:,:] ≈ gr[:,:,:]
gr2 = mean(@groupby(ds["data2"],Dates.Month(time)))
@test gds["data"][:,:,:] ≈ gr[:,:,:]
@test gds["data2"][:,:,:] ≈ gr2[:,:,:]
@test gr2["data2"][:,:,:] ≈ gr2[:,:,:]
@test gds["lon"][:] == 1:size(data,1)
io = IOBuffer()
show(io,"text/plain",gr)
#@test occursin("array", String(take!(io)))
@test occursin("Dimensions", String(take!(io)))
io = IOBuffer()
show(io,"text/plain",gv)
@test occursin("array", String(take!(io)))
if VERSION > v"1.7"
# type inference does not work in julia 1.6
@test eltype(gv) == Array{Float32,3}
end
@test name(gr) == "data"
month_time = Dates.month.(ds[coordname][:])
ncdata = ds["data3"][:,:,:]
var_ref = cat([var(ncdata[:,:,findall(month_time .== m)],dims=3)
for m in 1:12]...,dims=3)
gvar = var(@groupby(ds["data3"],Dates.Month(time)))[:,:,:]
@test ismissing.(gvar) == ismissing.(var_ref)
@test collect(skipmissing(gvar[:])) ≈ collect(skipmissing(var_ref[:]))
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 8244 | #using NCDatasets
using Test
import CommonDataModel as CDM
using DataStructures
using Dates
import CommonDataModel:
@CF_str,
AbstractDataset,
AbstractVariable,
Attributes,
CatArrays,
Dimensions,
MemoryDataset,
checksum,
chunking,
dataset,
defVar,
defGroup,
deflate,
dimnames,
fillvalue,
parentdataset,
sync,
variable
function example_file(TDS,i,array, fname = tempname();
varname = "var")
@debug "fname $fname"
TDS(fname,"c") do ds
# Dimensions
ds.dim["lon"] = size(array,1)
ds.dim["lat"] = size(array,2)
ds.dim["time"] = Inf
# Declare variables
ncvar = defVar(ds,varname, Float64, ("lon", "lat", "time"),
fillvalue = -9999.0)
ncvar.attrib["field"] = "u-wind, scalar, series"
ncvar.attrib["units"] = "meter second-1"
ncvar.attrib["long_name"] = "surface u-wind component"
ncvar.attrib["time"] = "time"
ncvar.attrib["coordinates"] = "lon lat"
nclat = defVar(ds,"lat", Float64, ("lat",))
nclat.attrib["units"] = "degrees_north"
nclon = defVar(ds,"lon", Float64, ("lon",))
nclon.attrib["units"] = "degrees_east"
nclon.attrib["modulo"] = 360.0
nctime = defVar(ds,"time", Float64, ("time",), attrib = OrderedDict(
"long_name" => "surface wind time",
"field" => "time, scalar, series",
"units" => "days since 2000-01-01 00:00:00",
"standard_name" => "time",
))
# Global attributes
ds.attrib["history"] = "foo"
# Define variables
g = defGroup(ds,"group")
ncvarg = defVar(g,varname, Float64, ("lon", "lat", "time"),
attrib = OrderedDict(
"field" => "u-wind, scalar, series",
"units" => "meter second-1",
"long_name" => "surface u-wind component",
"time" => "time",
"coordinates" => "lon lat",
))
ncvar[:,:,1] = array
ncvarg[:,:,1] = array.+1
#nclon[:] = 1:size(array,1)
#nclat[:] = 1:size(array,2)
nctime.var[1] = i
nclon[:] = 1:size(array,1)
nclat[:] = 1:size(array,2)
end
return fname
end
TDS = MemoryDataset
#TDS = NCDataset
A = [randn(2,3),randn(2,3),randn(2,3)]
C = cat(A...; dims = 3)
CA = CatArrays.CatArray(3,A...)
idx_global_local = CatArrays.index_global_local(CA,(1:1,1:1,1:1))
@inferred CatArrays.index_global_local(CA,(1:1,1:1,1:1))
@test CA[1:1,1:1,1:1] == C[1:1,1:1,1:1]
@test CA[1:1,1:1,1:2] == C[1:1,1:1,1:2]
@test CA[1:2,1:1,1:2] == C[1:2,1:1,1:2]
@test CA[:,:,1] == C[:,:,1]
@test CA[:,:,2] == C[:,:,2]
@test CA[:,2,:] == C[:,2,:]
@test CA[:,1:2:end,:] == C[:,1:2:end,:]
@test CA[1,1,1] == C[1,1,1]
@test CA[1,1,[1,2]] == C[1,1,[1,2]]
@test CA[1,1,[1,3]] == C[1,1,[1,3]]
@test CA[1,[1,3],:] == C[1,[1,3],:]
CA[2,2,:] = [1.,2.,3.]
@test A[1][2,2] == 1.
@test A[2][2,2] == 2.
@test A[3][2,2] == 3.
A = [rand(0:99,2,3,3),rand(0:99,2,3),rand(0:99,2,3)]
C = cat(A...; dims = 3)
CA = CatArrays.CatArray(3,A...)
@test CA[1,1,[1,2,4]] == C[1,1,[1,2,4]]
@test CA[1,1,[4,1,4]] == C[1,1,[4,1,4]]
A = [randn(2,3),randn(2,3),randn(2,3)]
C = cat(A...; dims = 3)
fnames = example_file.(TDS,1:3,A)
varname = "var"
#deferopen = false
for deferopen in (false,true)
local mfds, data
local lon
local buf, ds_merged, fname_merged, var, ncv
mfds = TDS(fnames, deferopen = deferopen);
@test haskey(mfds,varname)
var = variable(mfds,varname);
data = var[:,:,:]
@test C == var[:,:,:]
@test_throws BoundsError var[:,:,end+1]
@test_throws BoundsError mfds[varname].var[:,:,end+1]
@test mfds.attrib["history"] == "foo"
@test var.attrib["units"] == "meter second-1"
@test dimnames(var) == ("lon", "lat", "time")
# lon does not vary in time and thus there should be no aggregation
lon = variable(mfds,:lon);
@test lon.attrib["units"] == "degrees_east"
@test size(lon) == (size(data,1),)
var = mfds[varname]
@test C == var[:,:,:]
@test dimnames(var) == ("lon", "lat", "time")
@test mfds.dim["lon"] == size(C,1)
@test mfds.dim["lat"] == size(C,2)
@test mfds.dim["time"] == size(C,3)
@test mfds.dim["time"] == size(C,3)
# save a aggregated file
ds_merged = TDS(tempname(),"c")
write(ds_merged,mfds)
@test mfds.dim["time"] == size(C,3)
@test mfds["time"][:] == ds_merged["time"][:]
@test mfds["lon"][:] == ds_merged["lon"][:]
@test name(mfds[CF"time"]) == "time"
close(ds_merged)
# save subset of aggregated file
fname_merged = tempname()
ds_merged = TDS(fname_merged,"c")
write(ds_merged,view(mfds,lon = 1:1))
@test mfds["lon"][1:1] == ds_merged["lon"][:]
close(ds_merged)
# in-place load
ncv = mfds[varname].var
buffer = zeros(eltype(ncv),size(ncv))
load!(ncv,buffer,:,:,:)
@test buffer == C
# show
buf = IOBuffer()
show(buf,mfds)
occursin("time = 3",String(take!(buf)))
close(mfds)
end
# write
mfds = TDS(fnames,"a",deferopen = false);
mfds[varname][2,2,:] = 1:length(fnames)
mfds.attrib["history"] = "foo2"
mfds.attrib["new"] = "attrib"
@test TDS(fnames[2]).attrib["new"] == "attrib"
@test name(parentdataset(mfds.group["group"])) == "/"
@test chunking(mfds[varname]) == (:chunked, (2, 3, 1))
@test deflate(mfds[varname]) == (false, false, 0)
@test checksum(mfds[varname]) == :nochecksum
@test_throws ArgumentError TDS(fnames,"not-a-mode")
@test collect(keys(mfds)) == [varname, "lat", "lon", "time"]
@test keys(mfds.dim) == ["lon", "lat", "time"]
@test name(mfds) == "/"
@test size(mfds[varname]) == (2, 3, 3)
@test size(mfds[varname].var) == (2, 3, 3)
@test name(mfds[varname].var) == varname
@test name(mfds.group["group"]) == "group"
@test fillvalue(mfds[varname]) == -9999.
@test fillvalue(mfds[varname].var) == -9999.
@test dataset(mfds[varname]) == mfds
# create new dimension in all files
mfds.dim["newdim"] = 123;
sync(mfds)
close(mfds)
for n = 1:length(fnames)
TDS(fnames[n]) do ds
@test ds[varname][2,2,1] == n
end
end
TDS(fnames[1]) do ds
@test ds.attrib["history"] == "foo2"
end
TDS(fnames[1]) do ds
@test ds.dim["newdim"] == 123
end
# multi-file merge
ampl = rand(50,50)
vel = rand(50,50)
fnames = [example_file(TDS, 1, vel; varname = "vel"),
example_file(TDS, 1, ampl; varname = "ampl")]
ds = TDS(fnames,aggdim = "", deferopen = false);
@test ds["ampl"][:,:,1] == ampl
@test ds["vel"][:,:,1] == vel
@test sort(keys(ds)) == ["ampl", "lat", "lon", "time", "vel"]
# save a merged file
fname_merged = tempname()
TDS(fname_merged,"c") do ds_dest
write(ds_dest,ds)
end
ds_merged = TDS(fname_merged)
@test sort(collect(keys(ds_merged))) == ["ampl", "lat", "lon", "time", "vel"]
@test ds_merged["ampl"][:,:,1] == ampl
@test ds_merged["vel"][:,:,1] == vel
close(ds_merged)
nothing
# multi-file with different time units
fnames = [tempname(), tempname()]
times = [DateTime(2000,1,1), DateTime(2000,1,2)]
time_units = ["days since 2000-01-01","seconds since 2000-01-01"]
for i = 1:2
local ds
ds = TDS(fnames[i],"c")
defVar(ds,"time",times[i:i],("time",),attrib = Dict(
"units" => time_units[i],
"scale_factor" => Float64(10*i),
"add_offset" => Float64(i),
))
close(ds)
end
ds = TDS(fnames,aggdim = "time")
ds["time"][:] == times
close(ds)
# test cat
A = [randn(2,3),randn(2,3),randn(2,3)]
C = cat(A...; dims = 3)
fnames = example_file.(TDS, 1:3,A)
ds = TDS.(fnames)
vars = getindex.(ds,"var")
a = cat(vars...,dims=3);
close.(ds)
ds = TDS(fnames,aggdim = "new_dim", isnewdim = true)
@test ds.dim["new_dim"] == length(fnames)
@test ds["var"][:,:,:,:] == cat(A...; dims = 4)
@test size(ds["lon"]) == (size(A[1],1),length(A))
close(ds)
ds = TDS(fnames,aggdim = "new_dim", constvars = ["lon","lat"],
isnewdim = true)
@test ds["var"][:,:,:,:] == cat(A...; dims = 4)
@test ds.dim["new_dim"] == length(fnames)
@test size(ds["lon"]) == (size(A[1],1),)
@test size(ds["lat"]) == (size(A[1],2),)
close(ds)
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 473 | using Dates
function gen_file(TDS,time)
fname = tempname()
TDS(fname,"c") do ds
defVar(ds,"time",time,("time",));
end
return fname
end
fnames = [
gen_file(TDS,DateTime(2000,1,1):Day(1):DateTime(2009,12,31)),
gen_file(TDS,DateTime(2010,1,1):Day(1):DateTime(2012,12,31))
]
mfds = TDS(fnames; aggdim="time")
mfds2 = @select(mfds, 2005 ≤ Dates.year(time) ≤ 2011)
@test all(y -> 2005 <= y <= 2011, Dates.year.(mfds2["time"][:]))
close(mfds)
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 3307 | using Test
using Dates
using CommonDataModel:
GroupMapping,
MClass,
OverlappingGroupMapping,
dataindices,
rolling,
groupindices,
ndata,
ngroups
using Statistics
#include("memory_dataset.jl");
function test_mapping(gmap,coord,rolling_classes)
for k = 1:ndata(gmap)
for ku in groupindices(gmap,k)
@test time[k] in rolling_classes[ku]
end
end
for ku = 1:ngroups(gmap)
for k in dataindices(gmap,ku)
@test time[k] in rolling_classes[ku]
end
end
end
time = collect(DateTime(1980,1,1):Day(1):DateTime(1980,1,20))
coordinate = time
nn = 7
rolling_classes_ = [time[max(n-3,1):min(n+3,length(time))] for n = 1:length(time)]
#rolling_classes_ = [time[max(n-3,1):min(n+3,length(time))] for n = [4,8]]
#rolling_classes_ = [time[2] .+ Day.(-3:3), time[6] .+ Day.(-3:3)]
rolling_classes = [MClass(tuple(r...)) for r in rolling_classes_]
gmap = OverlappingGroupMapping(coordinate,rolling_classes)
test_mapping(gmap,coordinate,rolling_classes)
time = collect(DateTime(1980,1,1):Day(1):DateTime(1982,1,20))
class = Dates.Month.(time)
unique_class = sort(unique(class))
gmap = GroupMapping(class,unique_class)
for ku = 1:12
@test all(Dates.Month.(time[dataindices(gmap,ku)]) .== Dates.Month(ku))
end
for k = 1:length(time)
@test all(unique_class[collect(groupindices(gmap,k))] .== Dates.Month(time[k]))
end
# ----
TDS = MemoryDataset
time = DateTime(2000,1,1):Day(1):DateTime(2000,12,31);
data = rand(Float32.(-9:99),10,11,length(time))
varname = "data"
fname = tempname()
data3 = Array{Union{Missing,Float32},3}(undef,size(data))
data3 .= data
data3[1,1,:] .= missing
data3[1,2,1] = missing
TDS(fname,"c") do ds
defVar(ds,"lon",1:size(data,1),("lon",))
defVar(ds,"lat",1:size(data,2),("lat",))
defVar(ds,"time",time,("time",))
defVar(ds,"data",data,("lon","lat","time"))
defVar(ds,"data3",data3,("lon","lat","time"))
end
ds = TDS(fname)
# weekly averages
nn = 7
v = ds["data"]
gv = rolling(v,:time => 7)
data_weekly_ref = similar(data);
for reduce_fun in (sum,mean,var,std,median,maximum)
local gr
gr = reduce_fun(gv)
for n = 1:length(time)
data_weekly_ref[:,:,n] = reduce_fun(data[:,:,max(n-3,1):min(n+3,length(time))],dims=3)
end
for indices = [
(:,:,:),
(1:3,2:5,:),
(1:3,2,:),
(2,1:3,:),
(1:3,2:6,2:6),
(:,:,2),
]
@test gr[indices...] ≈ data_weekly_ref[indices...]
end
end
# test data with missing values
data3 = ds["data3"][:,:,:]
data_weekly_ref = similar(data3)
for n = 1:length(time)
data_weekly_ref[:,:,n] = mean(data3[:,:,max(n-3,1):min(n+3,length(time))],dims=3)
end
gr = mean(rolling(ds["data3"],:time => 7))[:,:,:]
@test ismissing.(gr) == ismissing.(data_weekly_ref)
@test collect(skipmissing(gr[:])) ≈ collect(skipmissing(data_weekly_ref[:]))
rolling_classes = [(t - Dates.Month(1)):Day(1):(t + Dates.Month(1)) for t in time]
extrema(length.(rolling_classes))
data_3monthly = mean(rolling(ds["data"],:time => rolling_classes))[:,:,:];
data_3monthly_ref = similar(data)
for n = 1:length(time)
k = findall(in(rolling_classes[n]),time)
data_3monthly_ref[:,:,n] = mean(data[:,:,k],dims=3)
end
@test data_3monthly_ref ≈ data_3monthly
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 6817 | #using NCDatasets
using Test
import CommonDataModel as CDM
using DataStructures
using Dates
import CommonDataModel:
AbstractDataset,
AbstractVariable,
Attributes,
Dimensions,
defDim,
defVar,
nonuniontype,
fillvalue
#include("memory_dataset.jl")
TDS = MemoryDataset
fname = tempname()
ds = MemoryDataset(fname,"c")
data = Array{Union{Missing,Float32},2}(undef,10,10)
data .= 3
data[2,2] = missing
add_offset = 12.
scale_factor = 45
fill_value = 9999.f0
v = defVar(ds,"temp",data,("lon","lat"),attrib = Dict(
"_FillValue" => fill_value,
"add_offset" => add_offset,
"scale_factor" => scale_factor))
v.var[1,1] = 1
@test v[1,1] ≈ scale_factor * v.var[1,1] + add_offset
@test ismissing(v[2,2])
@test v.attrib["_FillValue"] == fill_value
@test fillvalue(v) == fill_value
@test collect(CDM.dimnames(v)) == ["lon","lat"]
@test CDM.dim(v,"lon") == 10
io = IOBuffer()
CDM.show(io,"text/plain",v)
@test occursin("Attributes",String(take!(io)))
v = @test_logs (:warn,r"numeric") defVar(ds,"temp2",data,("lon","lat"),attrib = Dict("missing_value" => "bad_idea"))
for sample_data = ( -100:100,
'a':'z',
["AB","CD","EF"],
[NaN; 1:10],
)
local io, data, fill_value, mv, md, add_offset, scale_factor
local data2
fill_value = sample_data[1]
data = rand(sample_data[2:end],3,4)
md = MemoryDataset()
CDM.defDim(md,"lon",size(data,1))
CDM.defDim(md,"lat",size(data,2))
add_offset = 1
scale_factor = 10
mv = CDM.defVar(md,"data",eltype(data),("lon","lat"), attrib =
OrderedDict(
"_FillValue" => fill_value,
"add_offset" => add_offset,
"scale_factor" => scale_factor,
))
mv.var[:,:] .= data
@test "lon" in CDM.dimnames(mv)
@test CDM.name(mv) == "data"
md["data"][1,1] = missing
@test ismissing(md["data"][1,1])
@test md["data"].var[1,1] === fill_value
md["data"][1:2,1:2] .= missing
@test all(ismissing.(md["data"][1:2,1:2]))
@test all(md["data"].var[1:2,1:2] .=== fill_value)
if eltype(data) <: Number
mv.var[3,3] = 3
@test mv[3,3] == scale_factor * 3 + add_offset
mv[3,3] = scale_factor * 4 + add_offset
@test mv.var[3,3] == 4
elseif eltype(data) == Char
# ignore scale_factor and add_offset
mv.var[3,3] = 'z'
@test mv[3,3] == 'z'
mv[3,3] = 'y'
@test mv.var[3,3] == 'y'
end
# defVar(ds,name,data,dimnames)
data2 = replace(data,fill_value => missing)
mv = CDM.defVar(md,"data2",data2,("lon","lat"), attrib =
OrderedDict(
"_FillValue" => fill_value
))
@test all(mv[:,:] .=== data2)
end
# time
sample_data = -100:100
data = rand(sample_data,3,4)
md = MemoryDataset()
CDM.defDim(md,"lon",size(data,1))
CDM.defDim(md,"lat",size(data,2))
mv = CDM.defVar(md,"data",eltype(data),("lon","lat"), attrib = OrderedDict{String,Any}(
"units" => "days since 2000-01-01"))
CDM.defAttrib(mv,"foo","bar")
@test CDM.attrib(mv,"foo") == "bar"
mv.var[:,:] .= data
@test CDM.dim(md,"lon") == size(data,1)
@test CDM.dim(mv,"lon") == size(data,1)
CDM.defAttrib(md,"history", "lala")
@test "lon" in CDM.dimnames(mv)
@test CDM.name(mv) == "data"
time_origin = DateTime(2000,1,1)
@test md["data"][1,1] == time_origin + Dates.Millisecond(data[1,1]*24*60*60*1000)
md["data"][1,2] = DateTime(2000,2,1)
@test md["data"].var[1,2] == Dates.value(md["data"][1,2] - time_origin) ÷ (24*60*60*1000)
@test CDM.dataset(md["data"]) == md
md.attrib["history"] == "lala"
@test haskey(md.attrib,"history")
@test get(md.attrib,"foooo","bar") == "bar"
@test collect(keys(md.attrib)) == ["history"]
io = IOBuffer()
show(io,md.attrib)
str = String(take!(io))
@test occursin("history",str)
show(io,md.dim)
str = String(take!(io))
@test occursin("lon",str)
@test_logs (:warn, r".*analysis.*") CDM.defVar(md,"data2",eltype(data),("lon","lat"), attrib = OrderedDict{String,Any}( "units" => "days since analysis"));
close(md)
# Alternative to Missing for NetCDF fillvalue
fname = tempname()
data = randn(3,4)
fv = 9999
data[2,2] = fv
ds = TDS(fname,"c")
defDim(ds,"lon",size(data,1))
defDim(ds,"lat",size(data,2))
ncv = defVar(ds,"data",Float64,("lon","lat"),fillvalue = fv)
ncv.var[:,:] = data
ncv = CDM.cfvariable(ds,"data",maskingvalue = NaN)
@test eltype(ncv) == Float64
@test ncv[1,1] == data[1,1]
@test isnan(ncv[2,2])
ncv = CDM.cfvariable(ds,"data",maskingvalue = 42)
@test eltype(ncv) == Float64
@test ncv[1,1] == data[1,1]
@test ncv[2,2] == 42
ncv = CDM.cfvariable(ds,"data",maskingvalue = nothing)
@test eltype(ncv) == Union{Nothing,Float64}
@test ncv[1,1] == data[1,1]
@test isnothing(ncv[2,2])
# custom singelton type
struct MySingleton end
const mysingleton = MySingleton()
Base.promote_rule(::Type{MySingleton},S::Type) = Union{MySingleton,S}
ncv = CDM.cfvariable(ds,"data",maskingvalue = mysingleton)
@test eltype(ncv) == Union{MySingleton,Float64}
@test ncv[1,1] == data[1,1]
@test ncv[2,2] === mysingleton
close(ds)
add_offset = -1.0
scale_factor = 0.1
attributes = Dict("add_offset" => add_offset,"scale_factor" => scale_factor)
for Tbase in (UInt8, Int8, Float32, Float64, Int64, Char, String)
for _maskingvalue in (NaN,NaN32,missing,42,nothing,mysingleton)
local fname, data, fv, ds, ncv, T, varattrib
fname = tempname()
T = promote_type(Tbase,typeof(_maskingvalue))
data = Matrix{T}(undef,(3,4))
if Tbase == String
data[:,:] = rand(string.('a':'z'),size(data))
fv = "X"
else
data[:,:] = rand(Tbase(0):Tbase(10),size(data))
fv = Tbase(99)
end
data[2,2] = _maskingvalue
ds = TDS(fname,"c", maskingvalue = _maskingvalue)
varattrib =
if Tbase <: Number
attributes
else
[]
end
ncv = defVar(ds,"data",data,("lon","lat"),fillvalue = fv, attrib = varattrib)
@test CDM.maskingvalue(ds) === _maskingvalue
@test ncv.var[2,2] == fv
@test ncv[2,2] === _maskingvalue
if Tbase <: Number
@test ncv.var[1,1] * scale_factor + add_offset ≈ data[1,1]
@test ncv[1,1] ≈ data[1,1]
else
@test ncv[1,1] == data[1,1]
end
end
end
@test nonuniontype(Nothing,Union{Float64,Nothing}) == Float64
@test nonuniontype(Nothing,Union{Nothing,Float64}) == Float64
@test nonuniontype(Missing,Union{Float64,Missing}) == Float64
@test nonuniontype(Missing,Union{Missing,Float64}) == Float64
fname = tempname()
data = rand(4,5)
ds = TDS(fname,"c", maskingvalue = NaN)
ncv = defVar(ds,"data",data,("lon","lat"))
@test !haskey(ncv.attrib,"_FillValue")
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 9728 | import Base: size, getindex, setindex!
using DataStructures
using Dates
using IntervalSets
using Test
using Printf
import CommonDataModel:
@select,
AbstractVariable,
Near,
SubDataset,
coordinate_names,
coordinate_value,
dimnames,
select,
split_by_and
struct SelectableVariable{T,N,NT,TA} <: AbstractArray{T,N} where NT <: NTuple where TA <: AbstractArray{T,N}
dims::NT # tuple of named tuple
data::TA
end
Base.size(v::SelectableVariable) = size(v.data)
Base.getindex(v::SelectableVariable,indices...) = v.data[indices...]
Base.setindex!(v::SelectableVariable,data,indices...) = (v.data[indices...] = data)
function SelectableVariable(dims,data)
if dims isa NamedTuple
dims = (((dim=i, values = v, name = k) for (i,(k,v)) in enumerate(pairs(dims)))...,)
end
#@show dims
SelectableVariable{eltype(data),ndims(data),typeof(dims),typeof(data)}(dims,data);
end
"""
value = coordinate_value(v::SelectableVariable,name::Symbol)
Get the values of the coordinate names with the name `name` of the variable `v`.x
"""
function coordinate_value(v::SelectableVariable,name::Symbol)
for d in v.dims
if d.name == name
return (d.values,d.dim)
end
end
end
"""
symbols = coordinate_names(v::SelectableVariable)
List of symbols with all possible coordinate names related to the
variable `v`.
"""
coordinate_names(v::SelectableVariable) = getproperty.(v.dims,:name)
#import NCDatasets
#TDS = NCDatasets.NCDataset
TDS = MemoryDataset
lon = 1:9
data = collect(2:10)
v = SelectableVariable((lon = lon,),data);
@test coordinate_names(v) == (:lon,)
@test coordinate_value(v,:lon) == (lon,1)
target = 7.2
a = @select(v,lon ≈ 7.2)[]
a = @select(v,lon ≈ $target)[]
@test data[findmin(abs.(lon .- target))[2]] == a
target = 7.2
#a = @select(v,lon ≈ $target)
#@test data[findmin(abs.(lon .- target))[2]] == a
a = @select(v,lon ≈ $target ± 1)[]
@test v[findmin(x -> abs(x - target),lon)[2]] == a
a = select(v,:lon => Near(target,1))[]
@test v[findmin(x -> abs(x - target),lon)[2]] == a
a = @select(v,lon ≈ $target ± 1e-10)
@test a == []
a = @select(v,lon > 7.2)
@test data[lon .> 7.2] == a
a = @select(v,3 <= lon <= 7.2)
@test a == data[3 .<= lon .<= 7.2]
a = @select(v,3 <= lon^2 <= 7.2)
@test a == data[3 .<= lon.^2 .<= 7.2]
a = @select(v,lon <= 7.2)
@test a == data[lon .<= 7.2]
a = select(v,:lon => lon -> lon <= 7.2)
@test a == data[lon .<= 7.2]
a = select(v,:lon => <=(7.2))
@test a == data[lon .<= 7.2]
exp = :(lon > 10 && lat < 10 && time > 2 && lon < 20)
sub_exp = split_by_and(exp)
@test length(sub_exp) == 4
exp = :(lon > 10)
sub_exp = split_by_and(exp)
@test length(sub_exp) == 1
lon = 1:9
lat = 1:10
data = randn(9,10)
v = SelectableVariable((lon = lon,lat = lat),data);
a = @select(v,lon <= 7.2 && lat > 0)
@test a[:] == data[(lon .<= 7.2) .& (lat' .> 0)]
a = @select(v,3 <= lon <= 7.2 && 2 <= lat < 4)
@test a[:] == data[(3 .<= lon .<= 7.2) .& (2 .<= lat' .< 4)]
@select(v,3 <= lon <= 7.2 && 2 <= lat < 4) .= 12
i = findfirst(3 .<= lon .<= 7.2):findlast(3 .<= lon .<= 7.2)
j = findfirst(2 .<= lat .< 4):findlast(2 .<= lat .< 4)
@test all(data[i,j] .== 12)
lonr = (3,7.2)
latr = (2,4)
a = @select(v,$lonr[1] <= lon <= $lonr[2] && $latr[1] <= lat <= $latr[2])
i = findall(lonr[1] .<= lon .<= lonr[2])
j = findall(latr[1] .<= lat .<= latr[2])
@test a == data[i,j]
min_lon,max_lon = (3,7.2)
min_lat,max_lat = (2,4)
a = @select(v,$min_lon <= lon <= $max_lon && $min_lat <= lat <= $max_lat)
i = findall(x -> min_lon <= x <= max_lon,lon)
j = findall(x -> min_lat <= x <= max_lat,lat)
@test a == data[i,j]
# with time
lon = 1:9
lat = 2:11
dims = (lon = lon,lat = lat, time = DateTime(2001,1):Month(1):DateTime(2001,12))
sz = ((Int(length(d)) for d in dims)...,)
data = randn(sz)
v = SelectableVariable(dims,data);
a = @select(v,time ≈ DateTime(2001,12))
@test a == data[:,:,end]
a = @select(v,time ≈ DateTime(2001,12,2) ± Day(1))
@test a == data[:,:,end]
a = @select(v,time ≈ DateTime(2001,12,3) ± Day(1))
@test size(a,3) == 0
dims = (time = DateTime(2000,1,1):Day(1):DateTime(2009,12,31),)
sz = ((Int(length(d)) for d in dims)...,)
data = randn(sz)
v = SelectableVariable(dims,data);
a = @select(v,Dates.month(time) == 1)
@test a == data[findall(time -> Dates.month(time) == 1,dims.time)]
# NetCDF
fname = tempname()
lon = -180:180
lat = -90:90
time = DateTime(2000,1,1):Day(1):DateTime(2000,1,3)
SST = randn(length(lon),length(lat),Int(length(time)))
TDS(fname,"c") do ds
defVar(ds,"lon",lon,("lon",));
defVar(ds,"lat",lat,("lat",));
defVar(ds,"time",time,("time",));
defVar(ds,"SST",SST,("lon","lat","time"));
defVar(ds,"unrelated",time,("time123",));
end
ds = TDS(fname,"r")
v = ds["SST"]
coord_value,dim_number = coordinate_value(v,:lon)
@test coord_value == lon
@test dim_number == 1
@test coordinate_names(ds["SST"]) == [:lon, :lat, :time]
v = @select(ds["SST"],30 <= lon <= 60)
ilon = findall(x -> 30 <= x <= 60,ds["lon"])
v2 = ds["SST"][ilon,:,:]
@test v == v2
v = @select(ds["SST"],time ≈ DateTime(2000,1,4));
i = findmin(x -> abs.(DateTime(2000,1,4) - x),time)[2]
@test v == ds["SST"][:,:,i]
v = @select(ds["SST"],time ≈ DateTime(2000,1,3,1) ± Hour(2))
i = findmin(x -> abs.(DateTime(2000,1,3,1) - x),time)[2]
@test v == ds["SST"][:,:,i]
v = @select(ds["SST"],30 <= lon <= 60 && 40 <= lat <= 90)
# For NetCDF this currently fails
# https://github.com/meggart/DiskArrays.jl/issues/131
ilon = findall(x -> 30 <= x <= 60,ds["lon"])
ilat = findall(x -> 40 <= x <= 90,ds["lat"])
v2 = ds["SST"][ilon,ilat,:]
@test v == v2
lonr = 30..60
latr = ClosedInterval(40, 90) # latitude range
v = @select(ds["SST"], lon ∈ $lonr && lat in $latr)
ilon = findall(x -> 30 <= x <= 60,ds["lon"])
ilat = findall(x -> 40 <= x <= 90,ds["lat"])
v2 = ds["SST"][ilon,ilat,:]
@test v == v2
v = @select(ds["SST"], lon ∈ $(30..60) && lat ∈ $(65 ± 25))
ilon = findall(x -> 30 <= x <= 60,ds["lon"])
ilat = findall(x -> 40 <= x <= 90,ds["lat"])
v2 = ds["SST"][ilon,ilat,:]
@test v == v2
v = @select(ds["SST"], lon ∈ 30..60 && lat ∈ 65 ± 25)
ilon = findall(x -> 30 <= x <= 60,ds["lon"])
ilat = findall(x -> 40 <= x <= 90,ds["lat"])
v2 = ds["SST"][ilon,ilat,:]
@test v == v2
in_lon_range(lon) = 30 <= lon <= 60
v = @select(ds["SST"], in_lon_range(lon))
ilon = findall(in_lon_range,ds["lon"])
v2 = ds["SST"][ilon,:,:]
@test v == v2
v = @select(ds["SST"],lon ≈ 3 && lat ≈ 6)
ilon = findmin(x -> abs(x-3),ds["lon"])[2]
ilat = findmin(x -> abs(x-6),ds["lat"])[2]
v2 = ds["SST"][ilon,ilat,:]
@test v == v2
v = @select(ds["SST"],lon ≈ 3 && lat ≈ 6 && time ≈ DateTime(2000,1,4) ± Day(1))[]
ilon = findmin(x -> abs(x-3),ds["lon"])[2]
ilat = findmin(x -> abs(x-6),ds["lat"])[2]
v2 = ds["SST"][ilon,ilat,end]
@test v == v2
ds_subset = SubDataset(ds,(lon = 1:3,))
@test ds_subset.dim["lon"] == 3
ds_subset = view(ds; lon = 1:3)
@test ds_subset.dim["lon"] == 3
ds_subset = @select(ds,30 <= lon <= 60 && 40 <= lat <= 90)
@test all(x -> 30 <= x <= 60,ds_subset["lon"][:])
@test all(x -> 40 <= x <= 90,ds_subset["lat"][:])
fname = "sample_series.nc"
fname = tempname()
time = DateTime(2000,1,1):Day(1):DateTime(2009,12,31)
salinity = randn(Int(length(time))) .+ 35
temperature = Vector{Union{Float64,Missing}}(rand(0:40,Int(length(time))))
temperature[end] = missing
TDS(fname,"c") do ds
defVar(ds,"time",time,("time",));
defVar(ds,"salinity",salinity,("time",));
defVar(ds,"temperature",temperature,("time",),fillvalue = -9999.);
end
ds = TDS(fname)
v = @select(ds["temperature"],Dates.month(time) == 1 && salinity >= 35)
v2 = ds["temperature"][findall((Dates.month.(time) .== 1) .& (salinity .>= 35))]
@test v == v2
# only values which are missing
v_subset = @select(ds,ismissing(temperature))
@test v_subset.dim["time"] == 1
close(ds)
function url(TDS,dt)
array = rand(1:99,360,181)
fname = tempname()
TDS(fname,"c") do ds
# Dimensions
ds.dim["lon"] = size(array,1)
ds.dim["lat"] = size(array,2)
ds.dim["time"] = Inf
# Declare variables
ncvar = defVar(ds,"data", Float64, ("lon", "lat", "time"),
fillvalue = -9999)
nclat = defVar(ds,"lat", Float64, ("lat",))
nclon = defVar(ds,"lon", Float64, ("lon",))
nctime = defVar(ds,"time", Float64, ("time",), attrib = OrderedDict(
"units" => "days since 2000-01-01 00:00:00",
))
nctime[1] = dt
nclon[:] = 0:359
nclat[:] = -90:90
ncvar[:,:,1:size(array,3)] = array
end
return fname
end
fname_subset = tempname()
times = DateTime(1992,1,1):Dates.Day(1):DateTime(1992,1,3)
ds = TDS(url.(TDS,times),aggdim = "time",deferopen=false);
ds_subset = @select(ds,30 <= lon <= 60 && 40 <= lat <= 90)
TDS(fname_subset,"c") do ds_dest
write(ds_dest,ds_subset)
end
close(ds)
ds = TDS(fname_subset)
@test all(lon -> 30 <= lon <= 60,ds["lon"][:])
@test all(lat -> 40 <= lat <= 90,ds["lat"][:])
close(ds)
# issue NCDatasets 196
time = DateTime(1000,1,1):Dates.Day(1):DateTime(2000,1,1)
data = 1:length(time)
fname = tempname()
TDS(fname,"c") do ds
defVar(ds,"time",time,("time",))
defVar(ds,"data",data,("time",))
end
data1 = TDS(fname) do ds
@select(ds["data"],Dates.month(time) == 1)[:]
end;
@test data[Dates.month.(time) .== 1] == data1
ds = TDS(fname)
ds1 = @select(ds,Dates.month(time) == 1)
outfname = tempname()
TDS(outfname,"c") do ds_dest
write(ds_dest,ds1)
end
close(ds)
ds = TDS(outfname)
@test all(Dates.month.(ds["time"][:]) .== 1)
close(ds)
ds = TDS(fname)
data1 = @select(ds["data"],Dates.month(time) == 1)
t = data1["time"][:]
@test all(Dates.month.(t) .== 1)
close(ds)
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 4840 |
#import NCDatasets
using CommonDataModel: subsub, SubDataset, SubVariable, chunking, deflate, path, @select
using DataStructures
using Test
#TDS = NCDatasets.NCDataset
TDS = MemoryDataset
@test subsub((1:10,),(2:10,)) == (2:10,)
@test subsub((2:10,),(2:9,)) == (3:10,)
@test subsub((2:2:10,),(2:3,)) == (4:2:6,)
@test subsub((:,),(2:4,)) == (2:4,)
@test subsub((2:2:10,),(3,)) == (6,)
@test subsub((2:2:10,:),(2:3,2:4)) == (4:2:6,2:4)
@test subsub((2:2:10,:),(2:3,2)) == (4:2:6,2)
@test subsub((1,:),(2:3,)) == (1,2:3)
@test subsub((1,:),(1,)) == (1,1)
A = rand(10,10)
ip = (2:2:10,:)
i = (2:3,2:4)
j = subsub(ip,i)
A[ip...][i...] == A[j...]
fname = tempname()
ds = TDS(fname,"c", attrib = OrderedDict(
"title" => "title",
));
# Dimensions
ds.dim["lon"] = 10
ds.dim["lat"] = 11
# Declare variables
nclon = defVar(ds,"lon", Float64, ("lon",), attrib = OrderedDict(
"long_name" => "Longitude",
"standard_name" => "longitude",
"units" => "degrees_east",
))
nclat = defVar(ds,"lat", Float64, ("lat",), attrib = OrderedDict(
"long_name" => "Latitude",
"standard_name" => "latitude",
"units" => "degrees_north",
))
ncvar = defVar(ds,"bat", Float32, ("lon", "lat"), attrib = OrderedDict(
"long_name" => "elevation above sea level",
"standard_name" => "height",
"units" => "meters",
"_FillValue" => Float32(9.96921e36),
))
ncscalar = defVar(ds,"scalar", 12, ())
# Define variables
data = rand(Float32,10,11)
nclon[:] = 1:10
nclat[:] = 1:11
ncvar[:,:] = data
ncvar_view = view(ncvar,1:3,1:4)
@test parentindices(ncvar_view) == (1:3,1:4)
ncvar_view.attrib["foo"] = "bar"
@test ncvar_view.attrib["foo"] == "bar"
@test ncvar.attrib["foo"] == "bar"
@test SubVariable(ncvar)[:,:] == data
@test ncscalar[] == 12
@test collect(view(ds,lon=1:3)["scalar"])[1] == 12
@test Array(view(ncvar,1:3,1:4)) == Array(view(data,1:3,1:4))
@test ncvar_view[CartesianIndex(2,3)] == data[CartesianIndex(2,3)]
@test ncvar_view[CartesianIndex(2),3] == data[2,3]
@test chunking(ncvar_view)[1] == :contiguous
@test chunking(ncvar_view)[2] == size(ncvar_view)
@test deflate(ncvar_view) == deflate(ncvar)
list_indices = [
(:,:),(1:3,2:3),(2,:),(2,2:3),
(1:3:10,2:3),
(CartesianIndex(1,2):CartesianIndex(2,3),)
]
for indices = list_indices
local v
local ncvar2
ncvar2 = data[indices...]
v = view(ncvar,indices...);
@test size(v) == size(ncvar2)
@test Array(v) == ncvar2
end
ncvar2 = ncvar[:,2][1:2]
v = view(view(ncvar,:,2),1:2)
@test ncvar2 == v
data_view = view(view(data,:,1:2),1:2:6,:)
ncvar_view = view(view(ncvar,:,1:2),1:2:6,:)
@test data_view == Array(ncvar_view)
@test data_view == ncvar_view
ind = CartesianIndex(1,1)
@test ncvar_view[ind] == data_view[ind]
ind = CartesianIndices((1:2,1:2))
@test ncvar_view[ind] == data_view[ind]
@test ncvar[:,1:2][1:2:6,:] == Array(view(ncvar,:,1:2)[1:2:6,:])
ind = CartesianIndices((1:2,1:2))
@test ncvar[:,1:2][ind] == Array(view(ncvar,:,1:2)[ind])
# writing to a view
vdata = view(data,2:3,3:4)
vdata[2,:] = [1,1]
vncvar = view(ncvar,2:3,3:4)
vncvar[2,:] = [1,1]
@test data == collect(ncvar)
io = IOBuffer()
show(io,view(ncvar,:,:));
@test occursin("elevation",String(take!(io)))
# subset of dataset
indices = (lon = 3:4, lat = 1:3)
sds = SubDataset(ds,indices)
@test size(sds["lon"]) == (2,)
@test size(sds["lat"]) == (3,)
@test size(sds["bat"]) == (2,3)
@test sds["bat"][2,2] == ds["bat"][4,2]
@test "lon" in keys(sds)
indices = (lon = 1:2,)
sds = SubDataset(ds,indices)
@test size(sds["lon"]) == (2,)
@test size(sds["lat"]) == (11,)
@test size(sds["bat"]) == (2,11)
@test sds.dim["lon"] == 2
@test sds.dim["lat"] == 11
io = IOBuffer()
show(io,sds);
@test occursin("lon = 2",String(take!(io)))
@test dimnames(view(ncvar,:,1)) == ("lon",)
close(ds)
# test view of TDS
ds = TDS(tempname(),"c")
# Declare variables
nclon = defVar(ds,"lon", 1:10, ("lon",))
nclat = defVar(ds,"lat", 1:11, ("lat",))
ncvar = defVar(ds,"bat", zeros(10,11), ("lon", "lat"), attrib = OrderedDict(
"standard_name" => "height",
))
ds_subset = view(ds, lon = 2:3, lat = 2:4)
fname_slice = tempname()
ds_slice = TDS(fname_slice,"c")
write(ds_slice,ds_subset)
close(ds_slice)
@test TDS(fname_slice)["lon"][:] == 2:3
close(ds)
#
fname = tempname()
ds = TDS(fname,"c")
nclon = defVar(ds,"lon", 1:7, ("lon",))
nclat = defVar(ds,"lat", 1:10, ("lat",))
nctime = defVar(ds,"time", [DateTime(2000,1,1)], ("time",))
ncsst = defVar(ds,"sst", ones(7,10,1), ("lon", "lat", "time"))
ncsst3 = @select(ncsst,lon ≈ 2 && lat ≈ 3)
ss = ncsst3["time"]
@test ss[1] == DateTime(2000,1,1)
@test ndims(view(ncsst,:,1,1)) == 1
close(ds)
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 7497 | using Test
using Dates
using Printf
#using NCDatasets
#using NCDatasets: NetCDFError, load!
using DataStructures
using CFTime
using CommonDataModel:
MemoryDataset,
name,
load!
sz = (4,5)
filename = tempname()
if isfile(filename)
rm(filename)
end
#TDS = NCDataset
TDS = MemoryDataset
# The mode "c" stands for creating a new file (clobber)
TDS(filename,"c") do ds
# define the dimension "lon" and "lat"
ds.dim["lon"] = sz[1]
ds.dim["lat"] = sz[2]
v = defVar(ds,"small",Float64,("lon","lat"))
# @test_throws Union{NetCDFError,DimensionMismatch} v[:] = zeros(sz[1]+1,sz[2])
@test_throws DimensionMismatch v[1:sz[1],1:sz[2]] = zeros(sz[1]+1,sz[2])
@test_throws BoundsError v[sz[1]+1,1] = 1
@test_throws BoundsError v[-1,1] = 1
# variables
for T in [UInt8,Int8,UInt16,Int16,UInt32,Int32,UInt64,Int64,Float32,Float64,
Char,String]
#for T in [String]
local data
data, scalar_data =
if T == String
[Char(i+60) * Char(j+60) for i = 1:sz[1], j = 1:sz[2]], "abcde"
else
[T(i+2*j) for i = 1:sz[1], j = 1:sz[2]], T(100)
end
v = defVar(ds,"var-$T",T,("lon","lat"))
v[:,:] = data
@test v[:,:] == data[:,:]
# issue NCDatasets #33
@test Array(v) == data
@test v[2,:] == data[2,:]
@test v[:,3] == data[:,3]
@test v[2,3] == data[2,3]
# ignore extra index
@test v[2,3,1,1] == data[2,3,1,1]
# ignore extra index
@test v[2:3,3,1,1] == data[2:3,3,1,1]
@test v[[1,2,3],:] == data[[1,2,3],:]
# cartesian indices
ci = CartesianIndex(1,1):CartesianIndex(3,2)
@test v.var[ci] == data[ci]
# write scalar
v.var[1,1] = scalar_data
v.var[:,:] .= scalar_data
@test all(v.var[:,:][:] .== scalar_data)
# stridded write and read
v[1:2:end,1:2:end] = data[1:2:end,1:2:end]
@test all(v[1:2:end,1:2:end] .== data[1:2:end,1:2:end])
end
end
# quick interface
TDS(filename,"c") do ds
data = Int32[i+3*j for i = 1:sz[1], j = 1:sz[2]]
defVar(ds,"temp",data,("lon","lat"), attrib = [
"units" => "degree_Celsius",
"long_name" => "Temperature"
])
@test ds["temp"][:] == data[:]
@test eltype(ds["temp"].var) == Int32
@test ds.dim["lon"] == sz[1]
@test ds.dim["lat"] == sz[2]
# load in-place of Variable
data2 = similar(data)
load!(ds["temp"].var,data2,:,:)
@test data2 == data
data2 = zeros(eltype(data),sz[1],2)
load!(ds["temp"].var,data2,:,1:2)
@test data2 == data[:,1:2]
data2 = zeros(eltype(data),sz[1],1)
load!(ds["temp"].var,data2,:,1)
@test data2[:] == data[:,1]
# load in-place of CFVariable
ncv = ds["temp"]
data2 = similar(data)
buffer = zeros(eltype(ncv.var),size(ncv));
load!(ncv,data2,buffer,:,:)
@test data2 == data
# test Union{Missing,T}
data = [missing,1.,2.]
defVar(ds,"foo",data,("dim",), fillvalue = -9999.)
@test fillvalue(ds["foo"]) == -9999.
@test isequal(ds["foo"][:], data)
# load in-place of CFVariable with fill value
ncv = ds["foo"]
data2 = zeros(eltype(ncv),size(ncv))
buffer = zeros(eltype(ncv.var),size(ncv));
load!(ncv,data2,buffer,:)
@test isequal(data2,data)
# test Union{Missing,T} and default fill value (issue NCDatasets #38)
defVar(ds,"foo_default_fill_value",[missing,1.,2.],("dim",))
@test fillvalue(ds["foo_default_fill_value"]) == fillvalue(Float64)
@test isequal(ds["foo_default_fill_value"][:], [missing,1.,2.])
for DT in [DateTime,
DateTimeStandard,
DateTimeJulian,
DateTimeProlepticGregorian,
DateTimeAllLeap,
DateTimeNoLeap,
DateTime360Day
]
# test DateTime et al., array
data_dt = [DT(2000,1,1),DT(2000,1,2),DT(2000,1,3)]
defVar(ds,"foo_$(DT)",data_dt,("dim",))
data_dt2 = ds["foo_$(DT)"][:]
@test isequal(convert.(DT,data_dt2), data_dt)
# test DateTime et al. with missing array
data_dt = [missing,DT(2000,1,2),DT(2000,1,3)]
defVar(ds,"foo_$(DT)_with_fill_value",data_dt,("dim",))
data_dt2 = ds["foo_$(DT)_with_fill_value"][:]
@test ismissing(data_dt2[1])
@test isequal(convert.(DT,data_dt2[2:end]), data_dt[2:end])
end
defVar(ds,"scalar",123.)
@test ds["scalar"][1] == 123.
# test indexing with symbols #101
@test ds[:scalar][1] == 123.
end
# check bounds error
filename = tempname()
TDS(filename,"c") do ds
defVar(ds,"temp",randn(10,11),("lon","lat"))
@test_throws ErrorException defVar(ds,"salt",randn(10,12),("lon","lat"))
end
# check error for unknown variable
filename = tempname()
TDS(filename,"c") do ds
@test_throws KeyError ds["does_not_exist"]
end
# issue NCDatasets 23
# return type using CartesianIndex
filename = tempname()
ds = TDS(filename, "c");
ds.dim["lon"] = 5;
ds.dim["lat"] = 10;
ds.dim["time"] = Inf;
ncvar = defVar(ds, "var", Int64, ("lon", "lat", "time"));
nt = 25;
data = reshape(1:5*10*nt, 5, 10, nt);
ncvar[:,:,1:nt] = data;
close(ds);
ds = TDS(filename);
start = 1;
all(data[CartesianIndex(1, 1), start:end] .== ds["var"][CartesianIndex(1, 1), start:end])
data11 = ds["var"][CartesianIndex(1, 1), start:end]
close(ds)
@test typeof(data11[1]) == Int64
# issue NCDatasets #36
x, y = collect(1:10), collect(10:18)
filename = tempname()
TDS(filename, "c") do ds
defDim(ds, "x", length(x))
defVar(ds, "x", x, ("x",))
defDim(ds, "y", length(y))
defVar(ds, "y", y, ("y",))
end
# issue NCDatasets 155
filename = tempname()
x = 1.:0.1:10.
ds = TDS(filename,"c");
defDim(ds, "x", length(x))
ncv = defVar(ds, "x", Float64, ("x",))
ncv[:] = x
ds.attrib["x_range"] = x
close(ds)
# issue NCDatasets 180
filename = tempname()
ds = TDS(filename, "c")
sample_data = [UInt8(1),Int64(2),Float64(3.),"string",'a']
sample_data = [UInt8(1),"string"]
for data = sample_data
local ncv, T
T = typeof(data)
#= ncv = defVar(ds, "$(T)_scalar1", T, ())
ncv[] = data
@test ncv[] == data
=#
ncv = defVar(ds, "$(T)_scalar2", data, ())
@test ncv[] == data
#=
ncv = defVar(ds, "$(T)_scalar3", data)
@test ncv[] == data=#
end
close(ds)
# issue NCDatasets 207
filename_src = tempname()
ds_src = TDS(filename_src, "c")
data = [DateTime(2000,1,1),DateTime(2000,1,2)]
v_src = defVar(ds_src,"time",data,("time",), attrib = OrderedDict(
"units" => "days since 2000-01-01",
))
filename_dest = tempname()
ds_dest = TDS(filename_dest, "c")
v_dest = defVar(ds_dest,v_src)
v_dest[:] = v_dest[:] .+ Dates.Minute(30)
@test name(v_dest) == name(v_src)
@test v_dest[:] == v_src[:] .+ Dates.Minute(30)
close(ds_src)
close(ds_dest)
# issue NCDatasets 209
filename_src = tempname()
ds = TDS(filename_src, "c")
data = [1,2,3]
ncv = defVar(ds,"data",data,("data",))
@test isempty(ncv[Int[]])
close(ds)
# issue NCDatasets 211
filename = tempname()
ds = TDS(filename, "c")
data = [1,2,3]
ncv = defVar(ds,"data",data,("data",))
data2 = zeros(Int,1)
# data2 too small
@test_throws DimensionMismatch load!(ds["data"].var,data2,:)
data2 = zeros(Int,10)
# asking too many elements
@test_throws BoundsError load!(ds["data"].var,data2,1:10)
# issue 22
filename = tempname()
ds = TDS(filename, "c")
v = defVar(ds, "a", Int32, ())
@test ndims(Array(v)) == ndims(v) == 0
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 871 | # Benchmark to be run on Linux as root
using BenchmarkTools
using NCDatasets
using Dates
using CommonDataModel: @groupby
using CommonDataModel
fname = expanduser("~/sample_perf2.nc")
ds = NCDataset(fname)
data_f64 = Float64.(ds[:data][:,:,:])
println("runtime")
gm = @btime begin
write("/proc/sys/vm/drop_caches","3")
mean(@groupby(ds[:data],Dates.Month(time)))[:,:,:];
end
# Welford
gs = @btime begin
write("/proc/sys/vm/drop_caches","3")
std(@groupby(ds[:data],Dates.Month(time)))[:,:,:];
end
println("accuracy")
mean_ref = cat(
[mean(data_f64[:,:,findall(Dates.month.(ds[:time][:]) .== m)],dims=3)
for m in 1:12]...,dims=3);
std_ref = cat(
[std(data_f64[:,:,findall(Dates.month.(ds[:time][:]) .== m)],dims=3)
for m in 1:12]...,dims=3);
@show sqrt(mean((gm - mean_ref).^2))
@show sqrt(mean((gs - std_ref).^2))
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | code | 523 | # create the test file
using NCDatasets
using Dates
sz = (360,180)
time = DateTime(1980,1,1):Day(1):DateTime(2010,1,1);
varname = "data"
fname = expanduser("~/sample_perf2.nc")
isfile(fname) && rm(fname)
NCDataset(fname,"c") do ds
defVar(ds,"lon",1:sz[1],("lon",))
defVar(ds,"lat",1:sz[2],("lat",))
defVar(ds,"time",time,("time",))
ncv = defVar(ds,"data",Float32,("lon","lat","time"),attrib=Dict("foo" => "bar"))
for n = 1:length(time)
ncv[:,:,n] = randn(Float32,sz...) .+ 100
end
end
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | docs | 3030 | [](https://github.com/JuliaGeo/CommonDataModel.jl/actions)
[](http://app.codecov.io/github/JuliaGeo/CommonDataModel.jl?branch=main)
[](https://juliageo.github.io/CommonDataModel.jl/stable/)
[](https://juliageo.github.io/CommonDataModel.jl/dev/)
This package contains abstracts type definition to ensure compatibility of the package [GRIBDatasets](https://github.com/JuliaGeo/GRIBDatasets.jl) and [NCDatasets](https://github.com/Alexander-Barth/NCDatasets.jl) for manipulating GRIB and NetCDF files. This package aims to follow the [Common Data Model](https://docs.unidata.ucar.edu/netcdf-c/current/netcdf_data_model.html) and the [CF (climate and forecast models) Metadata Conventions](https://cfconventions.org/).
Features include:
* query and edit metadata of arrays and datasets
* virtually concatenating multiple files along a given dimension
* create a virtual subset (`view`) by indices or by values of coordinate variables (`CommonDataModel.select`, `CommonDataModel.@select`)
* group, map and reduce a variable (`CommonDataModel.groupby`, `CommonDataModel.@groupby`) and rolling reductions like running means `CommonDataModel.rolling`)
Here is minimal example for loading GRIB or NetCDF files.
``` julia
import CommonDataModel as CDM
import SomeDatasets # where SomeDatasets is either GRIBDatasets or NCDatasets
ds = SomeDatasets.Dataset("file_name")
# ntime is the number of time instances
ntime = ds.dim["time"] # or CDM.dims(ds)["time"]
# create an array-like structure v corresponding to variable temperature
v = ds["temperature"]
# load a subset
subdata = v[10:30,30:5:end]
# load all data
data = v[:,:]
# load a global attribute
title = ds.attrib["title"] # or CDM.attribs(ds)["title"]
close(ds)
```
Most users would typically import [`GRIBDatasets`](https://github.com/JuliaGeo/GRIBDatasets.jl) and [`NCDatasets`](https://github.com/Alexander-Barth/NCDatasets.jl) directly and not `CommonDataModel`. One should import `CommonDataModel` only to extent the functionality of `GRIBDatasets` and `NCDatasets`.
There is also an [`TIFFDatasets`](https://github.com/Alexander-Barth/TIFFDatasets.jl) package for GeoTIFF files and
[`ZarrDatasets`](https://github.com/JuliaGeo/ZarrDatasets.jl) package for Zarr datasets.
# File conversions
By implementing a common interface, GRIB files can be converted to NetCDF files using
`NCDatasets.write`:
```julia
using NCDatasets
using GRIBDatasets
using Downloads: download
grib_file = download("https://github.com/JuliaGeo/GRIBDatasets.jl/raw/98356af026ea39a5ec0b5e64e4289105492321f8/test/sample-data/era5-levels-members.grib")
netcdf_file = "test.nc"
NCDataset(netcdf_file,"c") do ds
NCDatasets.write(ds,GRIBDataset(grib_file))
end
```
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | docs | 636 | **Describe the bug**
A description of what the bug is.
**To Reproduce**
Please provide a minimal julia code example which reproduces the behavior (bug, performance regression, ...).
**Expected behavior**
A description of what you expected to happen.
**Environment**
- operating system: [e.g. Ubuntu XX.YY]
- Julia version: [e.g. julia 1.1.1, official binaries from https://julialang.org/downloads/]
- Output of the julia command `versioninfo()`
- CommonDataModel version:
- Output of `using Pkg; Pkg.status(mode=PKGMODE_MANIFEST)`
**Full output**
In case of an error, please paste the full error message and stack trace.
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"MIT"
] | 0.3.6 | d6fb5bf939a2753c74984b11434ea25d6c397a58 | docs | 3066 |
## Data types
In order to implement a new dataset based `CommonDataModel.jl`
one has to create two types derived from:
1. [`AbstractVariable`](@ref CommonDataModel.AbstractVariable): a variable with named dimension and metadata
2. [`AbstractDataset`](@ref CommonDataModel.AbstractDataset): a collection of variable with named dimension, metadata and sub-groups. The sub-groups are also `AbstractDataset`.
`CommonDataModel.jl` also provides a type `CFVariable` which wraps a type derived from `AbstractVariable` and applies the scaling described in
[`cfvariable`](@ref CommonDataModel.cfvariable).
Overview of methods:
| | get names | get values | set value | property |
|------------|-----------------------------------------------|-----------------------------------------|-------------------------------------------|--------|
| Dimensions | [`dimnames`](@ref CommonDataModel.dimnames) | [`dim`](@ref CommonDataModel.dim) | [`defDim`](@ref CommonDataModel.defDim) | `dim` |
| Attributes | [`attribnames`](@ref CommonDataModel.attribnames) | [`attrib`](@ref CommonDataModel.attrib) | [`defAttrib`](@ref CommonDataModel.defAttrib) | `attrib` |
| Variables | [`varnames`](@ref CommonDataModel.varnames) | [`variable`](@ref CommonDataModel.variable) | [`defVar`](@ref CommonDataModel.defVar) | - |
| Groups | [`groupnames`](@ref CommonDataModel.groupnames) | [`group`](@ref CommonDataModel.group) | [`defGroup`](@ref CommonDataModel.defGroup) | `group` |
For read-only datasets, the methods in "set value" column are not to be implemented.
Attributes can also be delete with the [`delAttrib`](@ref CommonDataModel.delAttrib) functions.
Every struct deriving from `AbstractDataset` have automaticaly the special properties `dim`, `attrib` and `group` which act like dictionaries (unless a field with this name already exists).
For `attrib`, calls to `keys`, `getindex` and `setindex!`, `delete!` are dispated to `attribnames`, `attrib`,`defAttrib`, and `delAttrib` respectively (and likewise for other properties). For example:
``` julia
using NCDatasets
ds = NCDataset("file.nc")
# setindex!(ds.attrib,...) here automatically calls defAttrib(ds,...)
ds.attrib["title"] = "my amazing results";
```
Variables can be accessed by directly indexing the `AbstractDataset`.
Every struct deriving from `AbstractVariable` has the properties `dim`, and `attrib`.
Current functionalities of CommonDataModel include:
* virtually concatenating files along a given dimension
* create a virtual subset (([`view`](@ref Base.view))) by indices or by values of coordinate variables ([`select`](@ref CommonDataModel.select), [`@select`](@ref CommonDataModel.@select))
* group, map and reduce a variable ([`groupby`](@ref CommonDataModel.groupby), [`@groupby`](@ref CommonDataModel.@groupby), [`rolling`](@ref CommonDataModel.rolling))
## API
```@autodocs
Modules = [CommonDataModel, CommonDataModel.CatArrays]
```
| CommonDataModel | https://github.com/JuliaGeo/CommonDataModel.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 56 | cd("..")
run(`cargo build --features extern --release`)
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 471 | using DocStringExtensions
using Documenter
using Polymers
makedocs(
format = Documenter.HTML(),
modules = [Polymers],
pages = [
"Home" => "index.md",
"Modules" => ["Physics" => "physics.md"],
"Examples" => [],
"Indices and Tables" =>
["General Index" => "genindex.md", "Module Index" => "modindex.md"],
],
sitename = "Polymers",
)
deploydocs(repo = "github.com/sandialabs/Polymers.git")
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 105 | module Polymers
const PROJECT_ROOT = string(dirname(@__FILE__), "/../")
include("physics/mod.jl")
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 259 | module Physics
include("single_chain/mod.jl")
"""
The Boltzmann constant in units of J/(mol⋅K).
"""
const BOLTZMANN_CONSTANT::Float64 = 8.314462618
"""
The Planck constant in units of J⋅ns/mol.
"""
const PLANCK_CONSTANT::Float64 = 0.06350779923502961
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 2891 | """
Single-chain models for polymer physics.
"""
module SingleChain
const ONE::Float64 = 1.0
const ZERO::Float64 = 1e-6
const POINTS::UInt128 = 64
function integrate(
fun::Function,
lower_lim::Float64,
upper_lim::Float64,
num_points::UInt128,
)
dx = (upper_lim - lower_lim) / num_points
return sum(map(fun, lower_lim .+ (0.5 .+ collect(range(0, num_points - 1))) * dx)) * dx
end
struct Parameters
abs_tol::Float64
rel_tol::Float64
rel_tol_thermodynamic_limit::Float64
log_log_tol::Float64
log_log_scale::Float64
number_of_loops::UInt32
hinge_mass_reference::Float64
hinge_mass_scale::Float64
link_length_reference::Float64
link_length_scale::Float64
persistance_length_reference::Float64
persistance_length_scale::Float64
number_of_links_minimum::UInt8
number_of_links_maximum::UInt8
link_stiffness_reference::Float64
link_stiffness_scale::Float64
link_energy_reference::Float64
link_energy_scale::Float64
nondimensional_persistance_length_small::Float64
nondimensional_link_stiffness_large::Float64
nondimensional_link_stiffness_big::Float64
nondimensional_link_stiffness_medium::Float64
well_width_reference::Float64
well_width_scale::Float64
nondimensional_well_width_small::Float64
nondimensional_end_to_end_length_per_link_reference::Float64
nondimensional_end_to_end_length_per_link_scale::Float64
nondimensional_end_to_end_length_per_link_small::Float64
nondimensional_force_reference::Float64
nondimensional_force_scale::Float64
nondimensional_force_small::Float64
nondimensional_potential_distance_reference::Float64
nondimensional_potential_distance_scale::Float64
nondimensional_potential_distance_small::Float64
nondimensional_potential_distance_large_1::Float64
nondimensional_potential_distance_large_2::Float64
nondimensional_potential_stiffness_reference::Float64
nondimensional_potential_stiffness_scale::Float64
nondimensional_potential_stiffness_small::Float64
nondimensional_potential_stiffness_large::Float64
temperature_reference::Float64
temperature_scale::Float64
end
parameters = Parameters(
1e-7,
1e-5,
1e-1,
5e-1,
12e-1,
8,
1e0,
1e-1,
1e0,
1e-2,
25e-1,
49e-1,
0x08,
0x19,
5e5,
99e4,
5e4,
99e3,
2e-2,
1e4,
1e3,
1e1,
99e-2,
5e-1,
1e-2,
5e-1,
99e-2,
25e-2,
5e1,
1e2,
75e-2,
1e0,
2e0,
33e-2,
1e1,
1e1 + 25e-1,
1e0,
2e0,
1e-3,
1e1,
3e2,
1e2,
)
include("ideal/mod.jl")
include("fjc/mod.jl")
include("efjc/mod.jl")
include("swfjc/mod.jl")
include("ufjc/mod.jl")
include("wlc/mod.jl")
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 56609 | module Test
using Test
using Polymers.Physics: BOLTZMANN_CONSTANT
using Polymers.Physics.SingleChain: parameters
using Polymers.Physics.SingleChain.Ideal: IDEAL
using Polymers.Physics.SingleChain.Fjc: FJC
using Polymers.Physics.SingleChain.Efjc: EFJC
using Polymers.Physics.SingleChain.Swfjc: SWFJC
@testset "physics::single_chain::test::fjc_ideal::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_fjc =
fjc.thermodynamics.isotensional.end_to_end_length(force, temperature)
end_to_end_length_ideal =
ideal.thermodynamics.isotensional.end_to_end_length(force, temperature)
residual_abs = end_to_end_length_fjc - end_to_end_length_ideal
residual_rel = residual_abs / end_to_end_length_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::fjc_ideal::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link_fjc =
fjc.thermodynamics.isotensional.end_to_end_length_per_link(force, temperature)
end_to_end_length_per_link_ideal =
ideal.thermodynamics.isotensional.end_to_end_length_per_link(force, temperature)
residual_abs = end_to_end_length_per_link_fjc - end_to_end_length_per_link_ideal
residual_rel = residual_abs / end_to_end_length_per_link_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::fjc_ideal::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
nondimensional_end_to_end_length_fjc =
fjc.thermodynamics.isotensional.nondimensional_end_to_end_length(
nondimensional_force,
)
nondimensional_end_to_end_length_ideal =
ideal.thermodynamics.isotensional.nondimensional_end_to_end_length(
nondimensional_force,
)
residual_abs =
nondimensional_end_to_end_length_fjc - nondimensional_end_to_end_length_ideal
residual_rel = residual_abs / nondimensional_end_to_end_length_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::fjc_ideal::nondimensional_end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
nondimensional_end_to_end_length_per_link_fjc =
fjc.thermodynamics.isotensional.nondimensional_end_to_end_length_per_link(
nondimensional_force,
)
nondimensional_end_to_end_length_per_link_ideal =
ideal.thermodynamics.isotensional.nondimensional_end_to_end_length_per_link(
nondimensional_force,
)
residual_abs =
nondimensional_end_to_end_length_per_link_fjc -
nondimensional_end_to_end_length_per_link_ideal
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::fjc_ideal::force" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_small *
(1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
force_fjc = fjc.thermodynamics.isometric.force(end_to_end_length, temperature)
force_ideal = ideal.thermodynamics.isometric.force(end_to_end_length, temperature)
residual_abs = force_fjc - force_ideal
residual_rel = residual_abs / force_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_end_to_end_length_per_link
end
end
@testset "physics::single_chain::test::fjc_ideal::nondimensional_force" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_small *
(1.0 - 0.5 * rand())
nondimensional_force_fjc = fjc.thermodynamics.isometric.nondimensional_force(
nondimensional_end_to_end_length_per_link,
)
nondimensional_force_ideal = ideal.thermodynamics.isometric.nondimensional_force(
nondimensional_end_to_end_length_per_link,
)
residual_abs = nondimensional_force_fjc - nondimensional_force_ideal
residual_rel = residual_abs / nondimensional_force_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_end_to_end_length_per_link
end
end
@testset "physics::single_chain::test::fjc_ideal::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_small *
(1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy_fjc = fjc.thermodynamics.isometric.helmholtz_free_energy(
end_to_end_length,
temperature,
)
helmholtz_free_energy_ideal = ideal.thermodynamics.isometric.helmholtz_free_energy(
end_to_end_length,
temperature,
)
residual_abs = helmholtz_free_energy_fjc - helmholtz_free_energy_ideal
residual_rel = residual_abs / helmholtz_free_energy_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_end_to_end_length_per_link
end
end
@testset "physics::single_chain::test::fjc_ideal::helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_small *
(1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy_per_link_fjc =
fjc.thermodynamics.isometric.helmholtz_free_energy_per_link(
end_to_end_length,
temperature,
)
helmholtz_free_energy_per_link_ideal =
ideal.thermodynamics.isometric.helmholtz_free_energy_per_link(
end_to_end_length,
temperature,
)
residual_abs =
helmholtz_free_energy_per_link_fjc - helmholtz_free_energy_per_link_ideal
residual_rel = residual_abs / helmholtz_free_energy_per_link_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_end_to_end_length_per_link
end
end
@testset "physics::single_chain::test::fjc_ideal::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_small *
(1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
relative_helmholtz_free_energy_fjc =
fjc.thermodynamics.isometric.relative_helmholtz_free_energy(
end_to_end_length,
temperature,
)
relative_helmholtz_free_energy_ideal =
ideal.thermodynamics.isometric.relative_helmholtz_free_energy(
end_to_end_length,
temperature,
)
residual_abs =
relative_helmholtz_free_energy_fjc - relative_helmholtz_free_energy_ideal
residual_rel = residual_abs / relative_helmholtz_free_energy_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_end_to_end_length_per_link
end
end
@testset "physics::single_chain::test::fjc_ideal::relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_small *
(1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
relative_helmholtz_free_energy_per_link_fjc =
fjc.thermodynamics.isometric.relative_helmholtz_free_energy_per_link(
end_to_end_length,
temperature,
)
relative_helmholtz_free_energy_per_link_ideal =
ideal.thermodynamics.isometric.relative_helmholtz_free_energy_per_link(
end_to_end_length,
temperature,
)
residual_abs =
relative_helmholtz_free_energy_per_link_fjc -
relative_helmholtz_free_energy_per_link_ideal
residual_rel = residual_abs / relative_helmholtz_free_energy_per_link_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_end_to_end_length_per_link
end
end
@testset "physics::single_chain::test::fjc_ideal::nondimensional_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_small *
(1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy_fjc =
fjc.thermodynamics.isometric.nondimensional_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
nondimensional_helmholtz_free_energy_ideal =
ideal.thermodynamics.isometric.nondimensional_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy_fjc -
nondimensional_helmholtz_free_energy_ideal
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_end_to_end_length_per_link
end
end
@testset "physics::single_chain::test::fjc_ideal::nondimensional_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_small *
(1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy_per_link_fjc =
fjc.thermodynamics.isometric.nondimensional_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
nondimensional_helmholtz_free_energy_per_link_ideal =
ideal.thermodynamics.isometric.nondimensional_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy_per_link_fjc -
nondimensional_helmholtz_free_energy_per_link_ideal
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_end_to_end_length_per_link
end
end
@testset "physics::single_chain::test::fjc_ideal::nondimensional_relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_small *
(1.0 - 0.5 * rand())
nondimensional_relative_helmholtz_free_energy_fjc =
fjc.thermodynamics.isometric.nondimensional_relative_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
)
nondimensional_relative_helmholtz_free_energy_ideal =
ideal.thermodynamics.isometric.nondimensional_relative_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
)
residual_abs =
nondimensional_relative_helmholtz_free_energy_fjc -
nondimensional_relative_helmholtz_free_energy_ideal
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_end_to_end_length_per_link
end
end
@testset "physics::single_chain::test::fjc_ideal::nondimensional_relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_small *
(1.0 - 0.5 * rand())
nondimensional_relative_helmholtz_free_energy_per_link_fjc =
fjc.thermodynamics.isometric.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
)
nondimensional_relative_helmholtz_free_energy_per_link_ideal =
ideal.thermodynamics.isometric.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
)
residual_abs =
nondimensional_relative_helmholtz_free_energy_per_link_fjc -
nondimensional_relative_helmholtz_free_energy_per_link_ideal
residual_rel =
residual_abs / nondimensional_relative_helmholtz_free_energy_per_link_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_end_to_end_length_per_link
end
end
@testset "physics::single_chain::test::fjc_ideal::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * number_of_links * link_length
gibbs_free_energy_fjc =
fjc.thermodynamics.isotensional.gibbs_free_energy(force, temperature)
gibbs_free_energy_ideal =
ideal.thermodynamics.isotensional.gibbs_free_energy(force, temperature)
residual_abs = gibbs_free_energy_fjc - gibbs_free_energy_ideal
residual_rel = residual_abs / gibbs_free_energy_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::fjc_ideal::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * number_of_links * link_length
gibbs_free_energy_per_link_fjc =
fjc.thermodynamics.isotensional.gibbs_free_energy_per_link(force, temperature)
gibbs_free_energy_per_link_ideal =
ideal.thermodynamics.isotensional.gibbs_free_energy_per_link(force, temperature)
residual_abs = gibbs_free_energy_per_link_fjc - gibbs_free_energy_per_link_ideal
residual_rel = residual_abs / gibbs_free_energy_per_link_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::fjc_ideal::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * number_of_links * link_length
relative_gibbs_free_energy_fjc =
fjc.thermodynamics.isotensional.relative_gibbs_free_energy(force, temperature)
relative_gibbs_free_energy_ideal =
ideal.thermodynamics.isotensional.relative_gibbs_free_energy(force, temperature)
residual_abs = relative_gibbs_free_energy_fjc - relative_gibbs_free_energy_ideal
residual_rel = residual_abs / relative_gibbs_free_energy_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::fjc_ideal::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * number_of_links * link_length
relative_gibbs_free_energy_per_link_fjc =
fjc.thermodynamics.isotensional.relative_gibbs_free_energy_per_link(
force,
temperature,
)
relative_gibbs_free_energy_per_link_ideal =
ideal.thermodynamics.isotensional.relative_gibbs_free_energy_per_link(
force,
temperature,
)
residual_abs =
relative_gibbs_free_energy_per_link_fjc -
relative_gibbs_free_energy_per_link_ideal
residual_rel = residual_abs / relative_gibbs_free_energy_per_link_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::fjc_ideal::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_gibbs_free_energy_fjc =
fjc.thermodynamics.isotensional.nondimensional_gibbs_free_energy(
nondimensional_force,
temperature,
)
nondimensional_gibbs_free_energy_ideal =
ideal.thermodynamics.isotensional.nondimensional_gibbs_free_energy(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_gibbs_free_energy_fjc - nondimensional_gibbs_free_energy_ideal
residual_rel = residual_abs / nondimensional_gibbs_free_energy_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::fjc_ideal::nondimensional_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_gibbs_free_energy_per_link_fjc =
fjc.thermodynamics.isotensional.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_gibbs_free_energy_per_link_ideal =
ideal.thermodynamics.isotensional.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_gibbs_free_energy_per_link_fjc -
nondimensional_gibbs_free_energy_per_link_ideal
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::fjc_ideal::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
nondimensional_relative_gibbs_free_energy_fjc =
fjc.thermodynamics.isotensional.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
)
nondimensional_relative_gibbs_free_energy_ideal =
ideal.thermodynamics.isotensional.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
)
residual_abs =
nondimensional_relative_gibbs_free_energy_fjc -
nondimensional_relative_gibbs_free_energy_ideal
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::fjc_ideal::nondimensional_relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
nondimensional_relative_gibbs_free_energy_per_link_fjc =
fjc.thermodynamics.isotensional.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
)
nondimensional_relative_gibbs_free_energy_per_link_ideal =
ideal.thermodynamics.isotensional.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
)
residual_abs =
nondimensional_relative_gibbs_free_energy_per_link_fjc -
nondimensional_relative_gibbs_free_energy_per_link_ideal
residual_rel =
residual_abs / nondimensional_relative_gibbs_free_energy_per_link_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::fjc_ideal::equilibrium_distribution" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_small *
(1.0 - 0.5 * rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
equilibrium_distribution_fjc =
fjc.thermodynamics.isometric.equilibrium_distribution(end_to_end_length)
equilibrium_distribution_ideal =
ideal.thermodynamics.isometric.equilibrium_distribution(end_to_end_length)
residual_abs = equilibrium_distribution_fjc - equilibrium_distribution_ideal
residual_rel = residual_abs / equilibrium_distribution_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_end_to_end_length_per_link
end
end
@testset "physics::single_chain::test::fjc_ideal::nondimensional_equilibrium_distribution" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_small *
(1.0 - 0.5 * rand())
nondimensional_equilibrium_distribution_fjc =
fjc.thermodynamics.isometric.nondimensional_equilibrium_distribution(
nondimensional_end_to_end_length_per_link,
)
nondimensional_equilibrium_distribution_ideal =
ideal.thermodynamics.isometric.nondimensional_equilibrium_distribution(
nondimensional_end_to_end_length_per_link,
)
residual_abs =
nondimensional_equilibrium_distribution_fjc -
nondimensional_equilibrium_distribution_ideal
residual_rel = residual_abs / nondimensional_equilibrium_distribution_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_end_to_end_length_per_link
end
end
@testset "physics::single_chain::test::fjc_ideal::equilibrium_radial_distribution" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_small *
(1.0 - 0.5 * rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
equilibrium_radial_distribution_fjc =
fjc.thermodynamics.isometric.equilibrium_radial_distribution(end_to_end_length)
equilibrium_radial_distribution_ideal =
ideal.thermodynamics.isometric.equilibrium_radial_distribution(
end_to_end_length,
)
residual_abs =
equilibrium_radial_distribution_fjc - equilibrium_radial_distribution_ideal
residual_rel = residual_abs / equilibrium_radial_distribution_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_end_to_end_length_per_link
end
end
@testset "physics::single_chain::test::fjc_ideal::nondimensional_equilibrium_radial_distribution" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
fjc = FJC(number_of_links, link_length, hinge_mass)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_small *
(1.0 - 0.5 * rand())
nondimensional_equilibrium_radial_distribution_fjc =
fjc.thermodynamics.isometric.nondimensional_equilibrium_radial_distribution(
nondimensional_end_to_end_length_per_link,
)
nondimensional_equilibrium_radial_distribution_ideal =
ideal.thermodynamics.isometric.nondimensional_equilibrium_radial_distribution(
nondimensional_end_to_end_length_per_link,
)
residual_abs =
nondimensional_equilibrium_radial_distribution_fjc -
nondimensional_equilibrium_radial_distribution_ideal
residual_rel = residual_abs / nondimensional_equilibrium_radial_distribution_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_end_to_end_length_per_link
end
end
@testset "physics::single_chain::test::efjc_ideal::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness = parameters.link_stiffness_scale
efjc = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_efjc =
efjc.thermodynamics.isotensional.end_to_end_length(force, temperature)
end_to_end_length_ideal =
ideal.thermodynamics.isotensional.end_to_end_length(force, temperature)
residual_abs = end_to_end_length_efjc - end_to_end_length_ideal
residual_rel = residual_abs / end_to_end_length_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::efjc_ideal::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness = parameters.link_stiffness_scale
efjc = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link_efjc =
efjc.thermodynamics.isotensional.end_to_end_length_per_link(force, temperature)
end_to_end_length_per_link_ideal =
ideal.thermodynamics.isotensional.end_to_end_length_per_link(force, temperature)
residual_abs = end_to_end_length_per_link_efjc - end_to_end_length_per_link_ideal
residual_rel = residual_abs / end_to_end_length_per_link_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::efjc_ideal::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness = parameters.link_stiffness_scale
efjc = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_efjc =
efjc.thermodynamics.isotensional.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)
nondimensional_end_to_end_length_ideal =
ideal.thermodynamics.isotensional.nondimensional_end_to_end_length(
nondimensional_force,
)
residual_abs =
nondimensional_end_to_end_length_efjc - nondimensional_end_to_end_length_ideal
residual_rel = residual_abs / nondimensional_end_to_end_length_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::efjc_ideal::nondimensional_end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness = parameters.link_stiffness_scale
efjc = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link_efjc =
efjc.thermodynamics.isotensional.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_end_to_end_length_per_link_ideal =
ideal.thermodynamics.isotensional.nondimensional_end_to_end_length_per_link(
nondimensional_force,
)
residual_abs =
nondimensional_end_to_end_length_per_link_efjc -
nondimensional_end_to_end_length_per_link_ideal
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::swfjc_ideal::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
well_width = parameters.nondimensional_well_width_small * link_length
swfjc = SWFJC(number_of_links, link_length, hinge_mass, well_width)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_swfjc =
swfjc.thermodynamics.isotensional.end_to_end_length(force, temperature)
end_to_end_length_ideal =
ideal.thermodynamics.isotensional.end_to_end_length(force, temperature)
residual_abs = end_to_end_length_swfjc - end_to_end_length_ideal
residual_rel = residual_abs / end_to_end_length_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::swfjc_ideal::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
well_width = parameters.nondimensional_well_width_small * link_length
swfjc = SWFJC(number_of_links, link_length, hinge_mass, well_width)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link_swfjc =
swfjc.thermodynamics.isotensional.end_to_end_length_per_link(force, temperature)
end_to_end_length_per_link_ideal =
ideal.thermodynamics.isotensional.end_to_end_length_per_link(force, temperature)
residual_abs = end_to_end_length_per_link_swfjc - end_to_end_length_per_link_ideal
residual_rel = residual_abs / end_to_end_length_per_link_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::swfjc_ideal::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
well_width = parameters.nondimensional_well_width_small * link_length
swfjc = SWFJC(number_of_links, link_length, hinge_mass, well_width)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
nondimensional_end_to_end_length_swfjc =
swfjc.thermodynamics.isotensional.nondimensional_end_to_end_length(
nondimensional_force,
)
nondimensional_end_to_end_length_ideal =
ideal.thermodynamics.isotensional.nondimensional_end_to_end_length(
nondimensional_force,
)
residual_abs =
nondimensional_end_to_end_length_swfjc - nondimensional_end_to_end_length_ideal
residual_rel = residual_abs / nondimensional_end_to_end_length_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::swfjc_ideal::nondimensional_end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
well_width = parameters.nondimensional_well_width_small * link_length
swfjc = SWFJC(number_of_links, link_length, hinge_mass, well_width)
ideal = IDEAL(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
nondimensional_end_to_end_length_per_link_swfjc =
swfjc.thermodynamics.isotensional.nondimensional_end_to_end_length_per_link(
nondimensional_force,
)
nondimensional_end_to_end_length_per_link_ideal =
ideal.thermodynamics.isotensional.nondimensional_end_to_end_length_per_link(
nondimensional_force,
)
residual_abs =
nondimensional_end_to_end_length_per_link_swfjc -
nondimensional_end_to_end_length_per_link_ideal
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link_ideal
@test abs(residual_rel) <= parameters.rel_tol_thermodynamic_limit &&
abs(residual_rel) <= nondimensional_force
end
end
@testset "physics::single_chain::test::swfjc_fjc::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
well_width = parameters.nondimensional_well_width_small * link_length
swfjc = SWFJC(number_of_links, link_length, hinge_mass, well_width)
fjc = FJC(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_swfjc =
swfjc.thermodynamics.isotensional.end_to_end_length(force, temperature)
end_to_end_length_fjc =
fjc.thermodynamics.isotensional.end_to_end_length(force, temperature)
residual_abs = end_to_end_length_swfjc - end_to_end_length_fjc
@test abs(residual_abs) <= number_of_links * well_width
end
end
@testset "physics::single_chain::test::swfjc_fjc::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
well_width = parameters.nondimensional_well_width_small * link_length
swfjc = SWFJC(number_of_links, link_length, hinge_mass, well_width)
fjc = FJC(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link_swfjc =
swfjc.thermodynamics.isotensional.end_to_end_length_per_link(force, temperature)
end_to_end_length_per_link_fjc =
fjc.thermodynamics.isotensional.end_to_end_length_per_link(force, temperature)
residual_abs = end_to_end_length_per_link_swfjc - end_to_end_length_per_link_fjc
@test abs(residual_abs) <= well_width
end
end
@testset "physics::single_chain::test::swfjc_fjc::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
well_width = parameters.nondimensional_well_width_small * link_length
swfjc = SWFJC(number_of_links, link_length, hinge_mass, well_width)
fjc = FJC(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
nondimensional_end_to_end_length_swfjc =
swfjc.thermodynamics.isotensional.nondimensional_end_to_end_length(
nondimensional_force,
)
nondimensional_end_to_end_length_fjc =
fjc.thermodynamics.isotensional.nondimensional_end_to_end_length(
nondimensional_force,
)
residual_abs =
nondimensional_end_to_end_length_swfjc - nondimensional_end_to_end_length_fjc
@test abs(residual_abs) <=
number_of_links * parameters.nondimensional_well_width_small
end
end
@testset "physics::single_chain::test::swfjc_fjc::nondimensional_end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links = parameters.number_of_links_maximum
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
well_width = parameters.nondimensional_well_width_small * link_length
swfjc = SWFJC(number_of_links, link_length, hinge_mass, well_width)
fjc = FJC(number_of_links, link_length, hinge_mass)
nondimensional_force = parameters.nondimensional_force_small * (1.0 - 0.5 * rand())
nondimensional_end_to_end_length_per_link_swfjc =
swfjc.thermodynamics.isotensional.nondimensional_end_to_end_length_per_link(
nondimensional_force,
)
nondimensional_end_to_end_length_per_link_fjc =
fjc.thermodynamics.isotensional.nondimensional_end_to_end_length_per_link(
nondimensional_force,
)
residual_abs =
nondimensional_end_to_end_length_per_link_swfjc -
nondimensional_end_to_end_length_per_link_fjc
@test abs(residual_abs) <= parameters.nondimensional_well_width_small
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 1202 | """
The extensible freely-jointed chain (EFJC) single-chain model.
"""
module Efjc
using DocStringExtensions
include("thermodynamics/mod.jl")
"""
The structure of the EFJC model.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The thermodynamic functions of the model.
"""
thermodynamics::Any
end
"""
Initializes and returns an instance of the EFJC model.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
Thermodynamics.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 3604 | module Test
using Test
using Polymers.Physics.SingleChain: parameters
using Polymers.Physics.SingleChain.Efjc: EFJC
@testset "physics::single_chain::efjc::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 1504 | """
The extensible freely-jointed chain (EFJC) model thermodynamics.
"""
module Thermodynamics
using DocStringExtensions
include("isometric/mod.jl")
include("isotensional/mod.jl")
"""
The structure of the thermodynamics of the EFJC model.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The thermodynamic functions of the model in the isometric ensemble.
"""
isometric::Any
"""
The thermodynamic functions of the model in the isotensional ensemble.
"""
isotensional::Any
end
"""
Initializes and returns an instance of the thermodynamics of the EFJC model.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
Isometric.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
Isotensional.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 71530 | module Test
using Test
using Polymers.Physics: BOLTZMANN_CONSTANT, PLANCK_CONSTANT
using Polymers.Physics.SingleChain: parameters
using Polymers.Physics.SingleChain.Efjc.Thermodynamics: EFJC
@testset "physics::single_chain::efjc::thermodynamics::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::thermodynamics::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.end_to_end_length(force, temperature)
force_out =
model.isometric.asymptotic.legendre.force(end_to_end_length, temperature)
residual_abs = force - force_out
residual_rel = residual_abs / force
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic::nondimensional_force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_force_out = model.isometric.asymptotic.legendre.nondimensional_force(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs = nondimensional_force - nondimensional_force_out
residual_rel = residual_abs / nondimensional_force
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.end_to_end_length(force, temperature)
helmholtz_free_energy_legendre =
model.isotensional.asymptotic.gibbs_free_energy(force, temperature) +
force * end_to_end_length
helmholtz_free_energy_legendre_out =
model.isometric.asymptotic.legendre.helmholtz_free_energy(
end_to_end_length,
temperature,
)
residual_abs =
helmholtz_free_energy_legendre - helmholtz_free_energy_legendre_out +
BOLTZMANN_CONSTANT *
temperature *
(
0.5 * log(2.0 * pi * BOLTZMANN_CONSTANT * temperature / link_stiffness) +
log(
8.0 *
pi^2 *
hinge_mass *
link_length^2 *
BOLTZMANN_CONSTANT *
temperature / PLANCK_CONSTANT^2,
)
)
residual_rel = residual_abs / helmholtz_free_energy_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic::helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.end_to_end_length(force, temperature)
end_to_end_length_per_link =
model.isotensional.asymptotic.end_to_end_length_per_link(force, temperature)
helmholtz_free_energy_per_link_legendre =
model.isotensional.asymptotic.gibbs_free_energy_per_link(force, temperature) +
force * end_to_end_length_per_link
helmholtz_free_energy_per_link_legendre_out =
model.isometric.asymptotic.legendre.helmholtz_free_energy_per_link(
end_to_end_length,
temperature,
)
residual_abs =
helmholtz_free_energy_per_link_legendre -
helmholtz_free_energy_per_link_legendre_out +
BOLTZMANN_CONSTANT *
temperature *
(
0.5 * log(2.0 * pi * BOLTZMANN_CONSTANT * temperature / link_stiffness) +
log(
8.0 *
pi^2 *
hinge_mass *
link_length^2 *
BOLTZMANN_CONSTANT *
temperature / PLANCK_CONSTANT^2,
)
) / number_of_links
residual_rel = residual_abs / helmholtz_free_energy_per_link_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.end_to_end_length(force, temperature)
relative_helmholtz_free_energy_legendre =
model.isotensional.asymptotic.relative_gibbs_free_energy(force, temperature) +
force * end_to_end_length
relative_helmholtz_free_energy_legendre_out =
model.isometric.asymptotic.legendre.relative_helmholtz_free_energy(
end_to_end_length,
temperature,
)
residual_abs =
relative_helmholtz_free_energy_legendre -
relative_helmholtz_free_energy_legendre_out
residual_rel = residual_abs / relative_helmholtz_free_energy_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic::relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.end_to_end_length(force, temperature)
end_to_end_length_per_link =
model.isotensional.asymptotic.end_to_end_length_per_link(force, temperature)
relative_helmholtz_free_energy_per_link_legendre =
model.isotensional.asymptotic.relative_gibbs_free_energy_per_link(
force,
temperature,
) + force * end_to_end_length_per_link
relative_helmholtz_free_energy_per_link_legendre_out =
model.isometric.asymptotic.legendre.relative_helmholtz_free_energy_per_link(
end_to_end_length,
temperature,
)
residual_abs =
relative_helmholtz_free_energy_per_link_legendre -
relative_helmholtz_free_energy_per_link_legendre_out
residual_rel = residual_abs / relative_helmholtz_free_energy_per_link_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic::nondimensional_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.isotensional.asymptotic.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_helmholtz_free_energy_legendre =
model.isotensional.asymptotic.nondimensional_gibbs_free_energy(
nondimensional_force,
temperature,
) + nondimensional_force * nondimensional_end_to_end_length
nondimensional_helmholtz_free_energy_legendre_out =
model.isometric.asymptotic.legendre.nondimensional_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy_legendre -
nondimensional_helmholtz_free_energy_legendre_out + (
0.5 * log(2.0 * pi * BOLTZMANN_CONSTANT * temperature / link_stiffness) +
log(
8.0 *
pi^2 *
hinge_mass *
link_length^2 *
BOLTZMANN_CONSTANT *
temperature / PLANCK_CONSTANT^2,
)
)
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic::nondimensional_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_helmholtz_free_energy_per_link_legendre =
model.isotensional.asymptotic.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
) + nondimensional_force * nondimensional_end_to_end_length_per_link
nondimensional_helmholtz_free_energy_per_link_legendre_out =
model.isometric.asymptotic.legendre.nondimensional_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy_per_link_legendre -
nondimensional_helmholtz_free_energy_per_link_legendre_out +
(
0.5 * log(2.0 * pi * BOLTZMANN_CONSTANT * temperature / link_stiffness) +
log(
8.0 *
pi^2 *
hinge_mass *
link_length^2 *
BOLTZMANN_CONSTANT *
temperature / PLANCK_CONSTANT^2,
)
) / number_of_links
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic::nondimensional_relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.isotensional.asymptotic.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_relative_helmholtz_free_energy_legendre =
model.isotensional.asymptotic.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
) + nondimensional_force * nondimensional_end_to_end_length
nondimensional_relative_helmholtz_free_energy_legendre_out =
model.isometric.asymptotic.legendre.nondimensional_relative_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_relative_helmholtz_free_energy_legendre -
nondimensional_relative_helmholtz_free_energy_legendre_out
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic::nondimensional_relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_relative_helmholtz_free_energy_per_link_legendre =
model.isotensional.asymptotic.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
) + nondimensional_force * nondimensional_end_to_end_length_per_link
nondimensional_relative_helmholtz_free_energy_per_link_legendre_out =
model.isometric.asymptotic.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_relative_helmholtz_free_energy_per_link_legendre -
nondimensional_relative_helmholtz_free_energy_per_link_legendre_out
residual_rel =
residual_abs / nondimensional_relative_helmholtz_free_energy_per_link_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_alternative::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.alternative.end_to_end_length(force, temperature)
force_out = model.isometric.asymptotic.alternative.legendre.force(
end_to_end_length,
temperature,
)
residual_abs = force - force_out
residual_rel = residual_abs / force
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_alternative::nondimensional_force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.alternative.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_force_out =
model.isometric.asymptotic.alternative.legendre.nondimensional_force(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs = nondimensional_force - nondimensional_force_out
residual_rel = residual_abs / nondimensional_force
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_alternative::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.alternative.end_to_end_length(force, temperature)
helmholtz_free_energy_legendre =
model.isotensional.asymptotic.alternative.gibbs_free_energy(
force,
temperature,
) + force * end_to_end_length
helmholtz_free_energy_legendre_out =
model.isometric.asymptotic.alternative.legendre.helmholtz_free_energy(
end_to_end_length,
temperature,
)
residual_abs =
helmholtz_free_energy_legendre - helmholtz_free_energy_legendre_out +
BOLTZMANN_CONSTANT *
temperature *
(
0.5 * log(2.0 * pi * BOLTZMANN_CONSTANT * temperature / link_stiffness) +
log(
8.0 *
pi^2 *
hinge_mass *
link_length^2 *
BOLTZMANN_CONSTANT *
temperature / PLANCK_CONSTANT^2,
)
)
residual_rel = residual_abs / helmholtz_free_energy_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_alternative::helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.alternative.end_to_end_length(force, temperature)
end_to_end_length_per_link =
model.isotensional.asymptotic.alternative.end_to_end_length_per_link(
force,
temperature,
)
helmholtz_free_energy_per_link_legendre =
model.isotensional.asymptotic.alternative.gibbs_free_energy_per_link(
force,
temperature,
) + force * end_to_end_length_per_link
helmholtz_free_energy_per_link_legendre_out =
model.isometric.asymptotic.alternative.legendre.helmholtz_free_energy_per_link(
end_to_end_length,
temperature,
)
residual_abs =
helmholtz_free_energy_per_link_legendre -
helmholtz_free_energy_per_link_legendre_out +
BOLTZMANN_CONSTANT *
temperature *
(
0.5 * log(2.0 * pi * BOLTZMANN_CONSTANT * temperature / link_stiffness) +
log(
8.0 *
pi^2 *
hinge_mass *
link_length^2 *
BOLTZMANN_CONSTANT *
temperature / PLANCK_CONSTANT^2,
)
) / number_of_links
residual_rel = residual_abs / helmholtz_free_energy_per_link_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_alternative::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.alternative.end_to_end_length(force, temperature)
relative_helmholtz_free_energy_legendre =
model.isotensional.asymptotic.alternative.relative_gibbs_free_energy(
force,
temperature,
) + force * end_to_end_length
relative_helmholtz_free_energy_legendre_out =
model.isometric.asymptotic.alternative.legendre.relative_helmholtz_free_energy(
end_to_end_length,
temperature,
)
residual_abs =
relative_helmholtz_free_energy_legendre -
relative_helmholtz_free_energy_legendre_out
residual_rel = residual_abs / relative_helmholtz_free_energy_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_alternative::relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.alternative.end_to_end_length(force, temperature)
end_to_end_length_per_link =
model.isotensional.asymptotic.alternative.end_to_end_length_per_link(
force,
temperature,
)
relative_helmholtz_free_energy_per_link_legendre =
model.isotensional.asymptotic.alternative.relative_gibbs_free_energy_per_link(
force,
temperature,
) + force * end_to_end_length_per_link
relative_helmholtz_free_energy_per_link_legendre_out =
model.isometric.asymptotic.alternative.legendre.relative_helmholtz_free_energy_per_link(
end_to_end_length,
temperature,
)
residual_abs =
relative_helmholtz_free_energy_per_link_legendre -
relative_helmholtz_free_energy_per_link_legendre_out
residual_rel = residual_abs / relative_helmholtz_free_energy_per_link_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_alternative::nondimensional_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.isotensional.asymptotic.alternative.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.alternative.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_helmholtz_free_energy_legendre =
model.isotensional.asymptotic.alternative.nondimensional_gibbs_free_energy(
nondimensional_force,
temperature,
) + nondimensional_force * nondimensional_end_to_end_length
nondimensional_helmholtz_free_energy_legendre_out =
model.isometric.asymptotic.alternative.legendre.nondimensional_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy_legendre -
nondimensional_helmholtz_free_energy_legendre_out + (
0.5 * log(2.0 * pi * BOLTZMANN_CONSTANT * temperature / link_stiffness) +
log(
8.0 *
pi^2 *
hinge_mass *
link_length^2 *
BOLTZMANN_CONSTANT *
temperature / PLANCK_CONSTANT^2,
)
)
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_alternative::nondimensional_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.alternative.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_helmholtz_free_energy_per_link_legendre =
model.isotensional.asymptotic.alternative.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
) + nondimensional_force * nondimensional_end_to_end_length_per_link
nondimensional_helmholtz_free_energy_per_link_legendre_out =
model.isometric.asymptotic.alternative.legendre.nondimensional_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy_per_link_legendre -
nondimensional_helmholtz_free_energy_per_link_legendre_out +
(
0.5 * log(2.0 * pi * BOLTZMANN_CONSTANT * temperature / link_stiffness) +
log(
8.0 *
pi^2 *
hinge_mass *
link_length^2 *
BOLTZMANN_CONSTANT *
temperature / PLANCK_CONSTANT^2,
)
) / number_of_links
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_alternative::nondimensional_relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.isotensional.asymptotic.alternative.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.alternative.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_relative_helmholtz_free_energy_legendre =
model.isotensional.asymptotic.alternative.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
) + nondimensional_force * nondimensional_end_to_end_length
nondimensional_relative_helmholtz_free_energy_legendre_out =
model.isometric.asymptotic.alternative.legendre.nondimensional_relative_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_relative_helmholtz_free_energy_legendre -
nondimensional_relative_helmholtz_free_energy_legendre_out
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_alternative::nondimensional_relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.alternative.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_relative_helmholtz_free_energy_per_link_legendre =
model.isotensional.asymptotic.alternative.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
) + nondimensional_force * nondimensional_end_to_end_length_per_link
nondimensional_relative_helmholtz_free_energy_per_link_legendre_out =
model.isometric.asymptotic.alternative.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_relative_helmholtz_free_energy_per_link_legendre -
nondimensional_relative_helmholtz_free_energy_per_link_legendre_out
residual_rel =
residual_abs / nondimensional_relative_helmholtz_free_energy_per_link_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_reduced::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.reduced.end_to_end_length(force, temperature)
force_out = model.isometric.asymptotic.reduced.legendre.force(
end_to_end_length,
temperature,
)
residual_abs = force - force_out
residual_rel = residual_abs / force
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_reduced::nondimensional_force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.reduced.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_force_out =
model.isometric.asymptotic.reduced.legendre.nondimensional_force(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs = nondimensional_force - nondimensional_force_out
residual_rel = residual_abs / nondimensional_force
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_reduced::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.reduced.end_to_end_length(force, temperature)
helmholtz_free_energy_legendre =
model.isotensional.asymptotic.reduced.gibbs_free_energy(force, temperature) +
force * end_to_end_length
helmholtz_free_energy_legendre_out =
model.isometric.asymptotic.reduced.legendre.helmholtz_free_energy(
end_to_end_length,
temperature,
)
residual_abs =
helmholtz_free_energy_legendre - helmholtz_free_energy_legendre_out +
BOLTZMANN_CONSTANT *
temperature *
(
0.5 * log(2.0 * pi * BOLTZMANN_CONSTANT * temperature / link_stiffness) +
log(
8.0 *
pi^2 *
hinge_mass *
link_length^2 *
BOLTZMANN_CONSTANT *
temperature / PLANCK_CONSTANT^2,
)
)
residual_rel = residual_abs / helmholtz_free_energy_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_reduced::helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.reduced.end_to_end_length(force, temperature)
end_to_end_length_per_link =
model.isotensional.asymptotic.reduced.end_to_end_length_per_link(
force,
temperature,
)
helmholtz_free_energy_per_link_legendre =
model.isotensional.asymptotic.reduced.gibbs_free_energy_per_link(
force,
temperature,
) + force * end_to_end_length_per_link
helmholtz_free_energy_per_link_legendre_out =
model.isometric.asymptotic.reduced.legendre.helmholtz_free_energy_per_link(
end_to_end_length,
temperature,
)
residual_abs =
helmholtz_free_energy_per_link_legendre -
helmholtz_free_energy_per_link_legendre_out +
BOLTZMANN_CONSTANT *
temperature *
(
0.5 * log(2.0 * pi * BOLTZMANN_CONSTANT * temperature / link_stiffness) +
log(
8.0 *
pi^2 *
hinge_mass *
link_length^2 *
BOLTZMANN_CONSTANT *
temperature / PLANCK_CONSTANT^2,
)
) / number_of_links
residual_rel = residual_abs / helmholtz_free_energy_per_link_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_reduced::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.reduced.end_to_end_length(force, temperature)
relative_helmholtz_free_energy_legendre =
model.isotensional.asymptotic.reduced.relative_gibbs_free_energy(
force,
temperature,
) + force * end_to_end_length
relative_helmholtz_free_energy_legendre_out =
model.isometric.asymptotic.reduced.legendre.relative_helmholtz_free_energy(
end_to_end_length,
temperature,
)
residual_abs =
relative_helmholtz_free_energy_legendre -
relative_helmholtz_free_energy_legendre_out
residual_rel = residual_abs / relative_helmholtz_free_energy_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_reduced::relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length =
model.isotensional.asymptotic.reduced.end_to_end_length(force, temperature)
end_to_end_length_per_link =
model.isotensional.asymptotic.reduced.end_to_end_length_per_link(
force,
temperature,
)
relative_helmholtz_free_energy_per_link_legendre =
model.isotensional.asymptotic.reduced.relative_gibbs_free_energy_per_link(
force,
temperature,
) + force * end_to_end_length_per_link
relative_helmholtz_free_energy_per_link_legendre_out =
model.isometric.asymptotic.reduced.legendre.relative_helmholtz_free_energy_per_link(
end_to_end_length,
temperature,
)
residual_abs =
relative_helmholtz_free_energy_per_link_legendre -
relative_helmholtz_free_energy_per_link_legendre_out
residual_rel = residual_abs / relative_helmholtz_free_energy_per_link_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_reduced::nondimensional_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.isotensional.asymptotic.reduced.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.reduced.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_helmholtz_free_energy_legendre =
model.isotensional.asymptotic.reduced.nondimensional_gibbs_free_energy(
nondimensional_force,
temperature,
) + nondimensional_force * nondimensional_end_to_end_length
nondimensional_helmholtz_free_energy_legendre_out =
model.isometric.asymptotic.reduced.legendre.nondimensional_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy_legendre -
nondimensional_helmholtz_free_energy_legendre_out + (
0.5 * log(2.0 * pi * BOLTZMANN_CONSTANT * temperature / link_stiffness) +
log(
8.0 *
pi^2 *
hinge_mass *
link_length^2 *
BOLTZMANN_CONSTANT *
temperature / PLANCK_CONSTANT^2,
)
)
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_reduced::nondimensional_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.reduced.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_helmholtz_free_energy_per_link_legendre =
model.isotensional.asymptotic.reduced.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
) + nondimensional_force * nondimensional_end_to_end_length_per_link
nondimensional_helmholtz_free_energy_per_link_legendre_out =
model.isometric.asymptotic.reduced.legendre.nondimensional_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy_per_link_legendre -
nondimensional_helmholtz_free_energy_per_link_legendre_out +
(
0.5 * log(2.0 * pi * BOLTZMANN_CONSTANT * temperature / link_stiffness) +
log(
8.0 *
pi^2 *
hinge_mass *
link_length^2 *
BOLTZMANN_CONSTANT *
temperature / PLANCK_CONSTANT^2,
)
) / number_of_links
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_reduced::nondimensional_relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.isotensional.asymptotic.reduced.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.reduced.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_relative_helmholtz_free_energy_legendre =
model.isotensional.asymptotic.reduced.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
) + nondimensional_force * nondimensional_end_to_end_length
nondimensional_relative_helmholtz_free_energy_legendre_out =
model.isometric.asymptotic.reduced.legendre.nondimensional_relative_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_relative_helmholtz_free_energy_legendre -
nondimensional_relative_helmholtz_free_energy_legendre_out
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::test::legendre_asymptotic_reduced::nondimensional_relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.isotensional.asymptotic.reduced.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_relative_helmholtz_free_energy_per_link_legendre =
model.isotensional.asymptotic.reduced.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
) + nondimensional_force * nondimensional_end_to_end_length_per_link
nondimensional_relative_helmholtz_free_energy_per_link_legendre_out =
model.isometric.asymptotic.reduced.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_relative_helmholtz_free_energy_per_link_legendre -
nondimensional_relative_helmholtz_free_energy_per_link_legendre_out
residual_rel =
residual_abs / nondimensional_relative_helmholtz_free_energy_per_link_legendre
@test abs(residual_abs) <= parameters.abs_tol ||
abs(residual_rel) <= parameters.rel_tol
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 1423 | """
The extensible freely-jointed chain (EFJC) model thermodynamics in the isometric ensemble.
"""
module Isometric
using DocStringExtensions
using ......Polymers: PROJECT_ROOT
include("asymptotic/mod.jl")
"""
The structure of the thermodynamics of the EFJC model in the isometric ensemble.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The thermodynamic functions of the model in the isometric ensemble approximated using an asymptotic approach.
"""
asymptotic::Any
end
"""
Initializes and returns an instance of the thermodynamics of the EFJC model in the isometric ensemble.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
Asymptotic.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 3791 | module Test
using Test
using Polymers.Physics.SingleChain: parameters
using Polymers.Physics.SingleChain.Efjc.Thermodynamics.Isometric: EFJC
@testset "physics::single_chain::efjc::thermodynamics::isometric::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 2124 | """
The extensible freely-jointed chain (EFJC) model thermodynamics in the isometric ensemble approximated using an asymptotic approach.
"""
module Asymptotic
using DocStringExtensions
using .......Polymers: PROJECT_ROOT
include("alternative/mod.jl")
include("reduced/mod.jl")
include("legendre/mod.jl")
"""
The structure of the thermodynamics of the EFJC model in the isometric ensemble approximated using an asymptotic approach.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The thermodynamic functions of the model in the isometric ensemble approximated using an alternative asymptotic approach.
"""
alternative::Any
"""
The thermodynamic functions of the model in the isometric ensemble approximated using a reduced asymptotic approach.
"""
reduced::Any
"""
The thermodynamic functions of the model in the isometric ensemble approximated using an asymptotic approach and a Legendre transformation.
"""
legendre::Any
end
"""
Initializes and returns an instance of the thermodynamics of the EFJC model in the isometric ensemble approximated using an asymptotic approach.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
Alternative.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
Reduced.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
Legendre.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 3874 | module Test
using Test
using Polymers.Physics.SingleChain: parameters
using Polymers.Physics.SingleChain.Efjc.Thermodynamics.Isometric.Asymptotic: EFJC
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 1625 | """
The extensible freely-jointed chain (EFJC) model thermodynamics in the isometric ensemble approximated using an alternative asymptotic approach.
"""
module Alternative
using DocStringExtensions
using ........Polymers: PROJECT_ROOT
include("legendre/mod.jl")
"""
The structure of the thermodynamics of the EFJC model in the isometric ensemble approximated using an alternative asymptotic approach.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The thermodynamic functions of the model in the isometric ensemble approximated using an alternative asymptotic approach and a Legendre transformation.
"""
legendre::Any
end
"""
Initializes and returns an instance of the thermodynamics of the EFJC model in the isometric ensemble approximated using an alternative asymptotic approach.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
Legendre.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 3969 | module Test
using Test
using Polymers.Physics.SingleChain: parameters
using Polymers.Physics.SingleChain.Efjc.Thermodynamics.Isometric.Asymptotic.Alternative:
EFJC
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 21987 | """
The extensible freely-jointed chain (EFJC) model thermodynamics in the isometric ensemble approximated using an alternative asymptotic approach and a Legendre transformation.
"""
module Legendre
using DocStringExtensions
using .........Polymers: PROJECT_ROOT
import ........Physics: BOLTZMANN_CONSTANT
"""
The structure of the thermodynamics of the EFJC model in the isometric ensemble approximated using an alternative asymptotic approach and a Legendre transformation.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The expected force ``f`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
force::Function
"""
The expected nondimensional force ``\\eta`` as a function of the applied nondimensional end-to-end length per link ``\\gamma``.
"""
nondimensional_force::Function
"""
The Helmholtz free energy ``\\psi`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
helmholtz_free_energy::Function
"""
The Helmholtz free energy per link ``\\psi/N_b`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
helmholtz_free_energy_per_link::Function
"""
The relative Helmholtz free energy ``\\Delta\\psi\\equiv\\psi(\\xi,T)-\\psi(0,T)`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
relative_helmholtz_free_energy::Function
"""
The relative Helmholtz free energy per link ``\\Delta\\psi/N_b`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
relative_helmholtz_free_energy_per_link::Function
"""
The nondimensional Helmholtz free energy ``N_b\\vartheta=\\beta\\psi`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``.
"""
nondimensional_helmholtz_free_energy::Function
"""
The nondimensional Helmholtz free energy per link ``\\vartheta\\equiv\\beta\\psi/N_b`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``.
"""
nondimensional_helmholtz_free_energy_per_link::Function
"""
The nondimensional relative Helmholtz free energy ``N_b\\Delta\\vartheta=\\beta\\Delta\\psi`` as a function of the applied nondimensional end-to-end length per link ``\\gamma``.
"""
nondimensional_relative_helmholtz_free_energy::Function
"""
The nondimensional relative Helmholtz free energy per link ``\\Delta\\vartheta\\equiv\\beta\\Delta\\psi/N_b`` as a function of the applied nondimensional end-to-end length per link ``\\gamma``
"""
nondimensional_relative_helmholtz_free_energy_per_link::Function
end
"""
The expected force as a function ``f`` of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function force(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_alternative_legendre_force,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The expected nondimensional force as a function ``\\eta`` of the applied nondimensional end-to-end length per link ``\\gamma``,
parameterized by the link length ``\\ell_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_force(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_end_to_end_length_per_link_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_alternative_legendre_nondimensional_force,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
),
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
)
end
"""
The Helmholtz free energy ``\\psi`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, link stiffness ``k_0``, and hinge mass ``m``,
```math
\\psi(\\xi, T) \\sim \\varphi\\left[f(\\xi, T)\\right] + \\xi f(\\xi, T) \\quad \\text{for } N_b\\gg 1,
```
where ``f(\\xi, T)`` is given by the Legendre transformation approximation above.
$(TYPEDSIGNATURES)
"""
function helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_alternative_legendre_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The Helmholtz free energy per link ``\\psi/N_b`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, link stiffness ``k_0``, and hinge mass ``m``.
$(TYPEDSIGNATURES)
"""
function helmholtz_free_energy_per_link(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_alternative_legendre_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The relative Helmholtz free energy ``\\Delta\\psi\\equiv\\psi(\\xi,T)-\\psi(0,T)`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_alternative_legendre_relative_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The relative Helmholtz free energy per link ``\\Delta\\psi/N_b`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_helmholtz_free_energy_per_link(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_alternative_legendre_relative_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The nondimensional Helmholtz free energy ``N_b\\vartheta=\\beta\\psi`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``, and hinge mass ``m``.
$(TYPEDSIGNATURES)
"""
function nondimensional_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_alternative_legendre_nondimensional_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
temperature,
)
end
"""
The nondimensional Helmholtz free energy per link ``\\vartheta\\equiv\\beta\\psi/N_b`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``, and hinge mass ``m``.
$(TYPEDSIGNATURES)
"""
function nondimensional_helmholtz_free_energy_per_link(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_alternative_legendre_nondimensional_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
temperature,
)
end
"""
The nondimensional relative Helmholtz free energy ``N_b\\Delta\\vartheta=\\beta\\Delta\\psi`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``,
parameterized by the number of links ``N_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_alternative_legendre_nondimensional_relative_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64),
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
),
number_of_links,
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
)
end
"""
The nondimensional relative Helmholtz free energy per link ``\\Delta\\vartheta\\equiv\\beta\\Delta\\psi/N_b`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``,
parameterized by the nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_end_to_end_length_per_link_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_alternative_legendre_nondimensional_relative_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
),
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
)
end
"""
Initializes and returns an instance of the thermodynamics of the EFJC model in the isometric ensemble approximated using an alternative asymptotic approach and a Legendre transformation.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
BOLTZMANN_CONSTANT::Float64 = 8.314462618
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
(end_to_end_length, temperature) -> force(
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
),
(nondimensional_end_to_end_length_per_link, temperature) -> nondimensional_force(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
),
(end_to_end_length, temperature) -> helmholtz_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
end_to_end_length,
temperature,
),
(end_to_end_length, temperature) -> helmholtz_free_energy_per_link(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
end_to_end_length,
temperature,
),
(end_to_end_length, temperature) -> relative_helmholtz_free_energy(
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
),
(end_to_end_length, temperature) -> relative_helmholtz_free_energy_per_link(
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
),
(nondimensional_end_to_end_length_per_link, temperature) ->
nondimensional_helmholtz_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
temperature,
),
(nondimensional_end_to_end_length_per_link, temperature) ->
nondimensional_helmholtz_free_energy_per_link(
number_of_links,
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
temperature,
),
(nondimensional_end_to_end_length_per_link, temperature) ->
nondimensional_relative_helmholtz_free_energy(
number_of_links,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
),
(nondimensional_end_to_end_length_per_link, temperature) ->
nondimensional_relative_helmholtz_free_energy_per_link(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 39488 | module Test
using Test
using Polymers.Physics: BOLTZMANN_CONSTANT
using Polymers.Physics.SingleChain: ZERO, parameters
using Polymers.Physics.SingleChain.Efjc.Thermodynamics.Isometric.Asymptotic.Alternative.Legendre:
EFJC
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::nondimensional::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force = model.nondimensional_force(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
force = model.force(end_to_end_length, temperature)
residual_abs =
force / BOLTZMANN_CONSTANT / temperature * link_length - nondimensional_force
residual_rel = residual_abs / nondimensional_force
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::nondimensional::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy = model.nondimensional_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy = model.helmholtz_free_energy(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_helmholtz_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::nondimensional::helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::nondimensional::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(end_to_end_length, temperature)
residual_abs =
relative_helmholtz_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::nondimensional::relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
relative_helmholtz_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::per_link::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy = model.helmholtz_free_energy(end_to_end_length, temperature)
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy / number_of_links - helmholtz_free_energy_per_link
residual_rel = residual_abs / helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::per_link::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(end_to_end_length, temperature)
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
relative_helmholtz_free_energy / number_of_links -
relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::per_link::nondimensional_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy = model.nondimensional_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy / number_of_links -
nondimensional_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::per_link::nondimensional_relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_relative_helmholtz_free_energy / number_of_links -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::relative::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy = model.helmholtz_free_energy(end_to_end_length, temperature)
helmholtz_free_energy_0 =
model.helmholtz_free_energy(ZERO * number_of_links * link_length, temperature)
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy - helmholtz_free_energy_0 - relative_helmholtz_free_energy
residual_rel = residual_abs / relative_helmholtz_free_energy
@test abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::relative::helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(end_to_end_length, temperature)
helmholtz_free_energy_per_link_0 = model.helmholtz_free_energy_per_link(
ZERO * number_of_links * link_length,
temperature,
)
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy_per_link - helmholtz_free_energy_per_link_0 -
relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / relative_helmholtz_free_energy_per_link
@test abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::relative::nondimensional_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy = model.nondimensional_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
nondimensional_helmholtz_free_energy_0 =
model.nondimensional_helmholtz_free_energy(ZERO, temperature)
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy - nondimensional_helmholtz_free_energy_0 -
nondimensional_relative_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy
@test abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::relative::nondimensional_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
nondimensional_helmholtz_free_energy_per_link_0 =
model.nondimensional_helmholtz_free_energy_per_link(ZERO, temperature)
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy_per_link -
nondimensional_helmholtz_free_energy_per_link_0 -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_per_link
@test abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::zero::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force_0 = model.force(ZERO * number_of_links * link_length, temperature)
@test abs(force_0) <=
3.1 * ZERO * number_of_links * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::zero::nondimensional_force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force_0 = model.nondimensional_force(ZERO, temperature)
@test abs(nondimensional_force_0) <= 3.1 * ZERO
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::zero::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_helmholtz_free_energy_0 = model.relative_helmholtz_free_energy(
ZERO * number_of_links * link_length,
temperature,
)
@test abs(relative_helmholtz_free_energy_0) <=
ZERO * number_of_links * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::zero::relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_helmholtz_free_energy_per_link_0 =
model.relative_helmholtz_free_energy_per_link(
ZERO * number_of_links * link_length,
temperature,
)
@test abs(relative_helmholtz_free_energy_per_link_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::zero::nondimensional_relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_0 =
model.nondimensional_relative_helmholtz_free_energy(ZERO, temperature)
@test abs(nondimensional_relative_helmholtz_free_energy_0) <= ZERO * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::zero::nondimensional_relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_per_link_0 =
model.nondimensional_relative_helmholtz_free_energy_per_link(ZERO, temperature)
@test abs(nondimensional_relative_helmholtz_free_energy_per_link_0) <= ZERO
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::connection::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
force = model.force(end_to_end_length, temperature)
h = parameters.rel_tol * number_of_links * link_length
force_from_derivative =
(
model.relative_helmholtz_free_energy(
end_to_end_length + 0.5 * h,
temperature,
) - model.relative_helmholtz_free_energy(
end_to_end_length - 0.5 * h,
temperature,
)
) / h
residual_abs = force - force_from_derivative
residual_rel = residual_abs / force
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::alternative::legendre::test::connection::nondimensional_force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force = model.nondimensional_force(
nondimensional_end_to_end_length_per_link,
temperature,
)
h = parameters.rel_tol
nondimensional_force_from_derivative =
(
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link + 0.5 * h,
temperature,
) - model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link - 0.5 * h,
temperature,
)
) / h
residual_abs = nondimensional_force - nondimensional_force_from_derivative
residual_rel = residual_abs / nondimensional_force
@test abs(residual_rel) <= h
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 21829 | """
The extensible freely-jointed chain (EFJC) model thermodynamics in the isometric ensemble approximated using an asymptotic approach and a Legendre transformation.
"""
module Legendre
using DocStringExtensions
using ........Polymers: PROJECT_ROOT
import .......Physics: BOLTZMANN_CONSTANT
"""
The structure of the thermodynamics of the EFJC model in the isometric ensemble approximated using an asymptotic approach and a Legendre transformation.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The expected force ``f`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
force::Function
"""
The expected nondimensional force ``\\eta`` as a function of the applied nondimensional end-to-end length per link ``\\gamma``.
"""
nondimensional_force::Function
"""
The Helmholtz free energy ``\\psi`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
helmholtz_free_energy::Function
"""
The Helmholtz free energy per link ``\\psi/N_b`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
helmholtz_free_energy_per_link::Function
"""
The relative Helmholtz free energy ``\\Delta\\psi\\equiv\\psi(\\xi,T)-\\psi(0,T)`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
relative_helmholtz_free_energy::Function
"""
The relative Helmholtz free energy per link ``\\Delta\\psi/N_b`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
relative_helmholtz_free_energy_per_link::Function
"""
The nondimensional Helmholtz free energy ``N_b\\vartheta=\\beta\\psi`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``.
"""
nondimensional_helmholtz_free_energy::Function
"""
The nondimensional Helmholtz free energy per link ``\\vartheta\\equiv\\beta\\psi/N_b`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``.
"""
nondimensional_helmholtz_free_energy_per_link::Function
"""
The nondimensional relative Helmholtz free energy ``N_b\\Delta\\vartheta=\\beta\\Delta\\psi`` as a function of the applied nondimensional end-to-end length per link ``\\gamma``.
"""
nondimensional_relative_helmholtz_free_energy::Function
"""
The nondimensional relative Helmholtz free energy per link ``\\Delta\\vartheta\\equiv\\beta\\Delta\\psi/N_b`` as a function of the applied nondimensional end-to-end length per link ``\\gamma``
"""
nondimensional_relative_helmholtz_free_energy_per_link::Function
end
"""
The expected force as a function ``f`` of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function force(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_legendre_force,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The expected nondimensional force as a function ``\\eta`` of the applied nondimensional end-to-end length per link ``\\gamma``,
parameterized by the link length ``\\ell_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_force(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_end_to_end_length_per_link_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_legendre_nondimensional_force,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
),
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
)
end
"""
The Helmholtz free energy ``\\psi`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, link stiffness ``k_0``, and hinge mass ``m``,
```math
\\psi(\\xi, T) \\sim \\varphi\\left[f(\\xi, T)\\right] + \\xi f(\\xi, T) \\quad \\text{for } N_b\\gg 1,
```
where ``f(\\xi, T)`` is given by the Legendre transformation approximation above.
$(TYPEDSIGNATURES)
"""
function helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_legendre_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The Helmholtz free energy per link ``\\psi/N_b`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, link stiffness ``k_0``, and hinge mass ``m``.
$(TYPEDSIGNATURES)
"""
function helmholtz_free_energy_per_link(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_legendre_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The relative Helmholtz free energy ``\\Delta\\psi\\equiv\\psi(\\xi,T)-\\psi(0,T)`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_legendre_relative_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The relative Helmholtz free energy per link ``\\Delta\\psi/N_b`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_helmholtz_free_energy_per_link(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_legendre_relative_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The nondimensional Helmholtz free energy ``N_b\\vartheta=\\beta\\psi`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``, and hinge mass ``m``.
$(TYPEDSIGNATURES)
"""
function nondimensional_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_legendre_nondimensional_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
temperature,
)
end
"""
The nondimensional Helmholtz free energy per link ``\\vartheta\\equiv\\beta\\psi/N_b`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``, and hinge mass ``m``.
$(TYPEDSIGNATURES)
"""
function nondimensional_helmholtz_free_energy_per_link(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_legendre_nondimensional_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
temperature,
)
end
"""
The nondimensional relative Helmholtz free energy ``N_b\\Delta\\vartheta=\\beta\\Delta\\psi`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``,
parameterized by the number of links ``N_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_legendre_nondimensional_relative_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64),
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
),
number_of_links,
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
)
end
"""
The nondimensional relative Helmholtz free energy per link ``\\Delta\\vartheta\\equiv\\beta\\Delta\\psi/N_b`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``,
parameterized by the nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_end_to_end_length_per_link_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_legendre_nondimensional_relative_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
),
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
)
end
"""
Initializes and returns an instance of the thermodynamics of the EFJC model in the isometric ensemble approximated using an asymptotic approach and a Legendre transformation.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
BOLTZMANN_CONSTANT::Float64 = 8.314462618
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
(end_to_end_length, temperature) -> force(
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
),
(nondimensional_end_to_end_length_per_link, temperature) -> nondimensional_force(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
),
(end_to_end_length, temperature) -> helmholtz_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
end_to_end_length,
temperature,
),
(end_to_end_length, temperature) -> helmholtz_free_energy_per_link(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
end_to_end_length,
temperature,
),
(end_to_end_length, temperature) -> relative_helmholtz_free_energy(
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
),
(end_to_end_length, temperature) -> relative_helmholtz_free_energy_per_link(
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
),
(nondimensional_end_to_end_length_per_link, temperature) ->
nondimensional_helmholtz_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
temperature,
),
(nondimensional_end_to_end_length_per_link, temperature) ->
nondimensional_helmholtz_free_energy_per_link(
number_of_links,
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
temperature,
),
(nondimensional_end_to_end_length_per_link, temperature) ->
nondimensional_relative_helmholtz_free_energy(
number_of_links,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
),
(nondimensional_end_to_end_length_per_link, temperature) ->
nondimensional_relative_helmholtz_free_energy_per_link(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 39120 | module Test
using Test
using Polymers.Physics: BOLTZMANN_CONSTANT
using Polymers.Physics.SingleChain: ZERO, parameters
using Polymers.Physics.SingleChain.Efjc.Thermodynamics.Isometric.Asymptotic.Legendre: EFJC
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::nondimensional::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force = model.nondimensional_force(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
force = model.force(end_to_end_length, temperature)
residual_abs =
force / BOLTZMANN_CONSTANT / temperature * link_length - nondimensional_force
residual_rel = residual_abs / nondimensional_force
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::nondimensional::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy = model.nondimensional_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy = model.helmholtz_free_energy(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_helmholtz_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::nondimensional::helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::nondimensional::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(end_to_end_length, temperature)
residual_abs =
relative_helmholtz_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::nondimensional::relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
relative_helmholtz_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::per_link::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy = model.helmholtz_free_energy(end_to_end_length, temperature)
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy / number_of_links - helmholtz_free_energy_per_link
residual_rel = residual_abs / helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::per_link::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(end_to_end_length, temperature)
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
relative_helmholtz_free_energy / number_of_links -
relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::per_link::nondimensional_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy = model.nondimensional_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy / number_of_links -
nondimensional_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::per_link::nondimensional_relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_relative_helmholtz_free_energy / number_of_links -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::relative::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy = model.helmholtz_free_energy(end_to_end_length, temperature)
helmholtz_free_energy_0 =
model.helmholtz_free_energy(ZERO * number_of_links * link_length, temperature)
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy - helmholtz_free_energy_0 - relative_helmholtz_free_energy
residual_rel = residual_abs / relative_helmholtz_free_energy
@test abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::relative::helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(end_to_end_length, temperature)
helmholtz_free_energy_per_link_0 = model.helmholtz_free_energy_per_link(
ZERO * number_of_links * link_length,
temperature,
)
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy_per_link - helmholtz_free_energy_per_link_0 -
relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / relative_helmholtz_free_energy_per_link
@test abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::relative::nondimensional_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy = model.nondimensional_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
nondimensional_helmholtz_free_energy_0 =
model.nondimensional_helmholtz_free_energy(ZERO, temperature)
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy - nondimensional_helmholtz_free_energy_0 -
nondimensional_relative_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy
@test abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::relative::nondimensional_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
nondimensional_helmholtz_free_energy_per_link_0 =
model.nondimensional_helmholtz_free_energy_per_link(ZERO, temperature)
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy_per_link -
nondimensional_helmholtz_free_energy_per_link_0 -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_per_link
@test abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::zero::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force_0 = model.force(ZERO * number_of_links * link_length, temperature)
@test abs(force_0) <=
3.1 * ZERO * number_of_links * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::zero::nondimensional_force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force_0 = model.nondimensional_force(ZERO, temperature)
@test abs(nondimensional_force_0) <= 3.1 * ZERO
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::zero::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_helmholtz_free_energy_0 = model.relative_helmholtz_free_energy(
ZERO * number_of_links * link_length,
temperature,
)
@test abs(relative_helmholtz_free_energy_0) <=
ZERO * number_of_links * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::zero::relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_helmholtz_free_energy_per_link_0 =
model.relative_helmholtz_free_energy_per_link(
ZERO * number_of_links * link_length,
temperature,
)
@test abs(relative_helmholtz_free_energy_per_link_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::zero::nondimensional_relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_0 =
model.nondimensional_relative_helmholtz_free_energy(ZERO, temperature)
@test abs(nondimensional_relative_helmholtz_free_energy_0) <= ZERO * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::zero::nondimensional_relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_per_link_0 =
model.nondimensional_relative_helmholtz_free_energy_per_link(ZERO, temperature)
@test abs(nondimensional_relative_helmholtz_free_energy_per_link_0) <= ZERO
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::connection::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
force = model.force(end_to_end_length, temperature)
h = parameters.rel_tol * number_of_links * link_length
force_from_derivative =
(
model.relative_helmholtz_free_energy(
end_to_end_length + 0.5 * h,
temperature,
) - model.relative_helmholtz_free_energy(
end_to_end_length - 0.5 * h,
temperature,
)
) / h
residual_abs = force - force_from_derivative
residual_rel = residual_abs / force
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::legendre::test::connection::nondimensional_force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force = model.nondimensional_force(
nondimensional_end_to_end_length_per_link,
temperature,
)
h = parameters.rel_tol
nondimensional_force_from_derivative =
(
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link + 0.5 * h,
temperature,
) - model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link - 0.5 * h,
temperature,
)
) / h
residual_abs = nondimensional_force - nondimensional_force_from_derivative
residual_rel = residual_abs / nondimensional_force
@test abs(residual_rel) <= h
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 1601 | """
The extensible freely-jointed chain (EFJC) model thermodynamics in the isometric ensemble approximated using a reduced asymptotic approach.
"""
module Reduced
using DocStringExtensions
using ........Polymers: PROJECT_ROOT
include("legendre/mod.jl")
"""
The structure of the thermodynamics of the EFJC model in the isometric ensemble approximated using a reduced asymptotic approach.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The thermodynamic functions of the model in the isometric ensemble approximated using a reduced asymptotic approach and a Legendre transformation.
"""
legendre::Any
end
"""
Initializes and returns an instance of the thermodynamics of the EFJC model in the isometric ensemble approximated using a reduced asymptotic approach.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
Legendre.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 3936 | module Test
using Test
using Polymers.Physics.SingleChain: parameters
using Polymers.Physics.SingleChain.Efjc.Thermodynamics.Isometric.Asymptotic.Reduced: EFJC
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 21932 | """
The extensible freely-jointed chain (EFJC) model thermodynamics in the isometric ensemble approximated using a reduced asymptotic approach and a Legendre transformation.
"""
module Legendre
using DocStringExtensions
using .........Polymers: PROJECT_ROOT
import ........Physics: BOLTZMANN_CONSTANT
"""
The structure of the thermodynamics of the EFJC model in the isometric ensemble approximated using a reduced asymptotic approach and a Legendre transformation.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The expected force ``f`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
force::Function
"""
The expected nondimensional force ``\\eta`` as a function of the applied nondimensional end-to-end length per link ``\\gamma``.
"""
nondimensional_force::Function
"""
The Helmholtz free energy ``\\psi`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
helmholtz_free_energy::Function
"""
The Helmholtz free energy per link ``\\psi/N_b`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
helmholtz_free_energy_per_link::Function
"""
The relative Helmholtz free energy ``\\Delta\\psi\\equiv\\psi(\\xi,T)-\\psi(0,T)`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
relative_helmholtz_free_energy::Function
"""
The relative Helmholtz free energy per link ``\\Delta\\psi/N_b`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``.
"""
relative_helmholtz_free_energy_per_link::Function
"""
The nondimensional Helmholtz free energy ``N_b\\vartheta=\\beta\\psi`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``.
"""
nondimensional_helmholtz_free_energy::Function
"""
The nondimensional Helmholtz free energy per link ``\\vartheta\\equiv\\beta\\psi/N_b`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``.
"""
nondimensional_helmholtz_free_energy_per_link::Function
"""
The nondimensional relative Helmholtz free energy ``N_b\\Delta\\vartheta=\\beta\\Delta\\psi`` as a function of the applied nondimensional end-to-end length per link ``\\gamma``.
"""
nondimensional_relative_helmholtz_free_energy::Function
"""
The nondimensional relative Helmholtz free energy per link ``\\Delta\\vartheta\\equiv\\beta\\Delta\\psi/N_b`` as a function of the applied nondimensional end-to-end length per link ``\\gamma``
"""
nondimensional_relative_helmholtz_free_energy_per_link::Function
end
"""
The expected force as a function ``f`` of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function force(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_reduced_legendre_force,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The expected nondimensional force as a function ``\\eta`` of the applied nondimensional end-to-end length per link ``\\gamma``,
parameterized by the link length ``\\ell_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_force(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_end_to_end_length_per_link_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_reduced_legendre_nondimensional_force,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
),
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
)
end
"""
The Helmholtz free energy ``\\psi`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, link stiffness ``k_0``, and hinge mass ``m``,
```math
\\psi(\\xi, T) \\sim \\varphi\\left[f(\\xi, T)\\right] + \\xi f(\\xi, T) \\quad \\text{for } N_b\\gg 1,
```
where ``f(\\xi, T)`` is given by the Legendre transformation approximation above.
$(TYPEDSIGNATURES)
"""
function helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_reduced_legendre_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The Helmholtz free energy per link ``\\psi/N_b`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, link stiffness ``k_0``, and hinge mass ``m``.
$(TYPEDSIGNATURES)
"""
function helmholtz_free_energy_per_link(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_reduced_legendre_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The relative Helmholtz free energy ``\\Delta\\psi\\equiv\\psi(\\xi,T)-\\psi(0,T)`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_reduced_legendre_relative_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The relative Helmholtz free energy per link ``\\Delta\\psi/N_b`` as a function of the applied end-to-end length ``\\xi`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_helmholtz_free_energy_per_link(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
end_to_end_length::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_reduced_legendre_relative_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
end_to_end_length_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
)
end
"""
The nondimensional Helmholtz free energy ``N_b\\vartheta=\\beta\\psi`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``, and hinge mass ``m``.
$(TYPEDSIGNATURES)
"""
function nondimensional_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_reduced_legendre_nondimensional_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
temperature,
)
end
"""
The nondimensional Helmholtz free energy per link ``\\vartheta\\equiv\\beta\\psi/N_b`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``, and hinge mass ``m``.
$(TYPEDSIGNATURES)
"""
function nondimensional_helmholtz_free_energy_per_link(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_reduced_legendre_nondimensional_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
temperature,
)
end
"""
The nondimensional relative Helmholtz free energy ``N_b\\Delta\\vartheta=\\beta\\Delta\\psi`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``,
parameterized by the number of links ``N_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_reduced_legendre_nondimensional_relative_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64),
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
),
number_of_links,
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
)
end
"""
The nondimensional relative Helmholtz free energy per link ``\\Delta\\vartheta\\equiv\\beta\\Delta\\psi/N_b`` as a function of the applied nondimensional end-to-end length per link ``\\gamma`` and temperature ``T``,
parameterized by the nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_end_to_end_length_per_link::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_end_to_end_length_per_link_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isometric_asymptotic_reduced_legendre_nondimensional_relative_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_end_to_end_length_per_link_i,
),
nondimensional_link_stiffness,
nondimensional_end_to_end_length_per_link,
)
end
"""
Initializes and returns an instance of the thermodynamics of the EFJC model in the isometric ensemble approximated using a reduced asymptotic approach and a Legendre transformation.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
BOLTZMANN_CONSTANT::Float64 = 8.314462618
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
(end_to_end_length, temperature) -> force(
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
),
(nondimensional_end_to_end_length_per_link, temperature) -> nondimensional_force(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
),
(end_to_end_length, temperature) -> helmholtz_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
end_to_end_length,
temperature,
),
(end_to_end_length, temperature) -> helmholtz_free_energy_per_link(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
end_to_end_length,
temperature,
),
(end_to_end_length, temperature) -> relative_helmholtz_free_energy(
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
),
(end_to_end_length, temperature) -> relative_helmholtz_free_energy_per_link(
number_of_links,
link_length,
link_stiffness,
end_to_end_length,
temperature,
),
(nondimensional_end_to_end_length_per_link, temperature) ->
nondimensional_helmholtz_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
temperature,
),
(nondimensional_end_to_end_length_per_link, temperature) ->
nondimensional_helmholtz_free_energy_per_link(
number_of_links,
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
temperature,
),
(nondimensional_end_to_end_length_per_link, temperature) ->
nondimensional_relative_helmholtz_free_energy(
number_of_links,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
),
(nondimensional_end_to_end_length_per_link, temperature) ->
nondimensional_relative_helmholtz_free_energy_per_link(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_end_to_end_length_per_link,
),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 39376 | module Test
using Test
using Polymers.Physics: BOLTZMANN_CONSTANT
using Polymers.Physics.SingleChain: ZERO, parameters
using Polymers.Physics.SingleChain.Efjc.Thermodynamics.Isometric.Asymptotic.Reduced.Legendre:
EFJC
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::nondimensional::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force = model.nondimensional_force(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
force = model.force(end_to_end_length, temperature)
residual_abs =
force / BOLTZMANN_CONSTANT / temperature * link_length - nondimensional_force
residual_rel = residual_abs / nondimensional_force
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::nondimensional::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy = model.nondimensional_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy = model.helmholtz_free_energy(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_helmholtz_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::nondimensional::helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::nondimensional::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(end_to_end_length, temperature)
residual_abs =
relative_helmholtz_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::nondimensional::relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
relative_helmholtz_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::per_link::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy = model.helmholtz_free_energy(end_to_end_length, temperature)
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy / number_of_links - helmholtz_free_energy_per_link
residual_rel = residual_abs / helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::per_link::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(end_to_end_length, temperature)
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
relative_helmholtz_free_energy / number_of_links -
relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::per_link::nondimensional_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy = model.nondimensional_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy / number_of_links -
nondimensional_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::per_link::nondimensional_relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_relative_helmholtz_free_energy / number_of_links -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::relative::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy = model.helmholtz_free_energy(end_to_end_length, temperature)
helmholtz_free_energy_0 =
model.helmholtz_free_energy(ZERO * number_of_links * link_length, temperature)
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy - helmholtz_free_energy_0 - relative_helmholtz_free_energy
residual_rel = residual_abs / relative_helmholtz_free_energy
@test abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::relative::helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(end_to_end_length, temperature)
helmholtz_free_energy_per_link_0 = model.helmholtz_free_energy_per_link(
ZERO * number_of_links * link_length,
temperature,
)
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(end_to_end_length, temperature)
residual_abs =
helmholtz_free_energy_per_link - helmholtz_free_energy_per_link_0 -
relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / relative_helmholtz_free_energy_per_link
@test abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::relative::nondimensional_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy = model.nondimensional_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
nondimensional_helmholtz_free_energy_0 =
model.nondimensional_helmholtz_free_energy(ZERO, temperature)
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy - nondimensional_helmholtz_free_energy_0 -
nondimensional_relative_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy
@test abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::relative::nondimensional_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
nondimensional_helmholtz_free_energy_per_link_0 =
model.nondimensional_helmholtz_free_energy_per_link(ZERO, temperature)
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy_per_link -
nondimensional_helmholtz_free_energy_per_link_0 -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_per_link
@test abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::zero::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force_0 = model.force(ZERO * number_of_links * link_length, temperature)
@test abs(force_0) <=
3.1 * ZERO * number_of_links * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::zero::nondimensional_force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force_0 = model.nondimensional_force(ZERO, temperature)
@test abs(nondimensional_force_0) <= 3.1 * ZERO
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::zero::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_helmholtz_free_energy_0 = model.relative_helmholtz_free_energy(
ZERO * number_of_links * link_length,
temperature,
)
@test abs(relative_helmholtz_free_energy_0) <=
ZERO * number_of_links * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::zero::relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_helmholtz_free_energy_per_link_0 =
model.relative_helmholtz_free_energy_per_link(
ZERO * number_of_links * link_length,
temperature,
)
@test abs(relative_helmholtz_free_energy_per_link_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::zero::nondimensional_relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_0 =
model.nondimensional_relative_helmholtz_free_energy(ZERO, temperature)
@test abs(nondimensional_relative_helmholtz_free_energy_0) <= ZERO * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::zero::nondimensional_relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_per_link_0 =
model.nondimensional_relative_helmholtz_free_energy_per_link(ZERO, temperature)
@test abs(nondimensional_relative_helmholtz_free_energy_per_link_0) <= ZERO
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::connection::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
end_to_end_length =
nondimensional_end_to_end_length_per_link * number_of_links * link_length
force = model.force(end_to_end_length, temperature)
h = parameters.rel_tol * number_of_links * link_length
force_from_derivative =
(
model.relative_helmholtz_free_energy(
end_to_end_length + 0.5 * h,
temperature,
) - model.relative_helmholtz_free_energy(
end_to_end_length - 0.5 * h,
temperature,
)
) / h
residual_abs = force - force_from_derivative
residual_rel = residual_abs / force
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isometric::asymptotic::reduced::legendre::test::connection::nondimensional_force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_end_to_end_length_per_link =
parameters.nondimensional_end_to_end_length_per_link_reference +
parameters.nondimensional_end_to_end_length_per_link_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force = model.nondimensional_force(
nondimensional_end_to_end_length_per_link,
temperature,
)
h = parameters.rel_tol
nondimensional_force_from_derivative =
(
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link + 0.5 * h,
temperature,
) - model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_end_to_end_length_per_link - 0.5 * h,
temperature,
)
) / h
residual_abs = nondimensional_force - nondimensional_force_from_derivative
residual_rel = residual_abs / nondimensional_force
@test abs(residual_rel) <= h
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 23437 | """
The extensible freely-jointed chain (EFJC) model thermodynamics in the isotensional ensemble.
"""
module Isotensional
using DocStringExtensions
using ......Polymers: PROJECT_ROOT
import .....Physics: BOLTZMANN_CONSTANT
include("asymptotic/mod.jl")
include("legendre/mod.jl")
"""
The structure of the thermodynamics of the EFJC model in the isotensional ensemble.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The thermodynamic functions of the model in the isotensional ensemble approximated using an asymptotic approach.
"""
asymptotic::Any
"""
The thermodynamic functions of the model in the isotensional ensemble approximated using a Legendre transformation.
"""
legendre::Any
"""
The expected end-to-end length ``\\xi`` as a function of the applied force ``f`` and temperature ``T``.
"""
end_to_end_length::Function
"""
The expected end-to-end length per link ``\\xi/N_b=\\ell_b\\gamma`` as a function of the applied force ``f`` and temperature ``T``.
"""
end_to_end_length_per_link::Function
"""
The expected nondimensional end-to-end length ``N_b\\gamma=\\xi/\\ell_b`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_end_to_end_length::Function
"""
The expected nondimensional end-to-end length per link ``\\gamma\\equiv\\xi/N_b\\ell_b`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_end_to_end_length_per_link::Function
"""
The Gibbs free energy ``\\varphi`` as a function of the applied force ``f`` and temperature ``T``.
"""
gibbs_free_energy::Function
"""
The Gibbs free energy per link ``\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``.
"""
gibbs_free_energy_per_link::Function
"""
The relative Gibbs free energy ``\\Delta\\varphi\\equiv\\varphi(f,T)-\\varphi(0,T)`` as a function of the applied force ``f`` and temperature ``T``.
"""
relative_gibbs_free_energy::Function
"""
The relative Gibbs free energy per link ``\\Delta\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``.
"""
relative_gibbs_free_energy_per_link::Function
"""
The nondimensional Gibbs free energy ``N_b\\varrho=\\beta\\varphi`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``.
"""
nondimensional_gibbs_free_energy::Function
"""
The nondimensional Gibbs free energy per link ``\\varrho\\equiv\\beta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``.
"""
nondimensional_gibbs_free_energy_per_link::Function
"""
The nondimensional relative Gibbs free energy ``N_b\\Delta\\varrho=\\beta\\Delta\\varphi`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_relative_gibbs_free_energy::Function
"""
The nondimensional relative Gibbs free energy per link ``\\Delta\\varrho\\equiv\\beta\\Delta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_relative_gibbs_free_energy_per_link::Function
end
"""
The expected end-to-end length ``N_b\\gamma=\\xi/\\ell_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``,
```math
\\xi(f, T) = -\\frac{\\partial\\varphi}{\\partial f}.
```
$(TYPEDSIGNATURES)
"""
function end_to_end_length(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, link_length_i, link_stiffness_i, force_i, temperature_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_end_to_end_length,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The expected end-to-end length per link ``\\xi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b`` and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function end_to_end_length_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_end_to_end_length_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64),
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The expected nondimensional end-to-end length ``N_b\\gamma=\\xi/\\ell_b`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the number of links ``N_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_end_to_end_length(
number_of_links::Union{UInt8,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, nondimensional_link_stiffness_i, nondimensional_force_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_nondimensional_end_to_end_length,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64),
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
number_of_links,
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
The expected nondimensional end-to-end length per link ``\\gamma\\equiv \\xi/N_b\\ell_b`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``,
calculated from [Balabaev and Khazanovich](https://doi.org/10.1134/S1990793109020109), [Buche et al.](https://doi.org/10.1103/PhysRevE.106.024502) as
```math
\\gamma(\\eta) = -\\frac{\\partial\\varrho}{\\partial\\eta} = \\mathcal{L}(\\eta) + \\frac{\\eta}{\\kappa}\\left[1 + \\frac{1 - \\mathcal{L}(\\eta)\\coth(\\eta)}{1 + (\\eta/\\kappa)\\coth(\\eta)}\\right] + \\frac{\\partial}{\\partial\\eta}\\,\\ln\\left[1+g(\\eta)\\right],
```
where ``\\mathcal{L}(x)=\\coth(x)-1/x`` is the Langevin function, and ``g(\\eta)`` is defined as
```math
g(\\eta) \\equiv \\frac{e^{\\eta}\\left(\\frac{\\eta}{\\kappa} + 1\\right) \\,\\mathrm{erf}\\left(\\frac{\\eta+\\kappa}{\\sqrt{2\\kappa}}\\right) - e^{-\\eta}\\left(\\frac{\\eta}{\\kappa} - 1\\right) \\,\\mathrm{erf}\\left(\\frac{\\eta-\\kappa}{\\sqrt{2\\kappa}}\\right)}{4\\sinh(\\eta)\\left[1 + (\\eta/\\kappa)\\coth(\\eta)\\right]} - \\frac{1}{2}.
```
$(TYPEDSIGNATURES)
"""
function nondimensional_end_to_end_length_per_link(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_force_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_nondimensional_end_to_end_length_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
The Gibbs free energy ``\\varphi`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, hinge mass ``m``, and link stiffness ``k_0``.
```math
\\varphi(f, T) = -kT\\ln Z(f, T).
```
$(TYPEDSIGNATURES)
"""
function gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
)
end
"""
The Gibbs free energy per link ``\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b``, hinge mass ``m``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function gibbs_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, hinge_mass_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64, Float64),
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
)
end
"""
The relative Gibbs free energy ``\\Delta\\varphi\\equiv\\varphi(f,T)-\\varphi(0,T)`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, link_length_i, link_stiffness_i, force_i, temperature_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_relative_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The relative Gibbs free energy per link ``\\Delta\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b`` and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_gibbs_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_relative_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64),
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The nondimensional Gibbs free energy ``N_b\\varrho=\\beta\\varphi`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, hinge mass ``m``, and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_nondimensional_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_force,
temperature,
)
end
"""
The nondimensional Gibbs free energy per link ``\\varrho\\equiv\\beta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``,
parameterized by the link length ``\\ell_b``, hinge mass ``m``, and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_gibbs_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_nondimensional_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64, Float64),
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
),
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_force,
temperature,
)
end
"""
The nondimensional relative Gibbs free energy ``N_b\\Delta\\varrho=\\beta\\Delta\\varphi`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the number of links ``N_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, nondimensional_link_stiffness_i, nondimensional_force_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_nondimensional_relative_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64),
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
number_of_links,
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
The nondimensional relative Gibbs free energy per link ``\\Delta\\varrho\\equiv\\beta\\Delta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``,
given by [Buche et al.](https://doi.org/10.1103/PhysRevE.106.024502) as
```math
\\Delta\\varrho(\\eta) = -\\frac{\\eta^2}{2\\kappa} - \\ln\\left[w^+(\\eta) + w^-(\\eta)\\right],
```
where the functions ``w^+(\\eta)`` and ``w^-(\\eta)`` are defined as as
```math
w^\\pm(\\eta) \\equiv e^{\\pm\\eta}\\left(\\frac{1}{\\kappa} \\pm \\frac{1}{\\eta}\\right) \\left[1 \\pm \\mathrm{erf}\\left(\\frac{\\eta\\pm\\kappa}{\\sqrt{2\\kappa}}\\right)\\right].
```
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_force_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_nondimensional_relative_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
Initializes and returns an instance of the thermodynamics of the EFJC model in the isotensional ensemble.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
BOLTZMANN_CONSTANT::Float64 = 8.314462618
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
Asymptotic.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
Legendre.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
(force, temperature) -> end_to_end_length(
number_of_links,
link_length,
link_stiffness,
force,
temperature,
),
(force, temperature) ->
end_to_end_length_per_link(link_length, link_stiffness, force, temperature),
(nondimensional_force, temperature) -> nondimensional_end_to_end_length(
number_of_links,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
(nondimensional_force, temperature) -> nondimensional_end_to_end_length_per_link(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
(force, temperature) -> gibbs_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
),
(force, temperature) -> gibbs_free_energy_per_link(
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
),
(force, temperature) -> relative_gibbs_free_energy(
number_of_links,
link_length,
link_stiffness,
force,
temperature,
),
(force, temperature) -> relative_gibbs_free_energy_per_link(
link_length,
link_stiffness,
force,
temperature,
),
(nondimensional_force, temperature) -> nondimensional_gibbs_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
temperature,
),
(nondimensional_force, temperature) -> nondimensional_gibbs_free_energy_per_link(
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
temperature,
),
(nondimensional_force, temperature) -> nondimensional_relative_gibbs_free_energy(
number_of_links,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
(nondimensional_force, temperature) ->
nondimensional_relative_gibbs_free_energy_per_link(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 106882 | module Test
using Test
using Polymers.Physics: BOLTZMANN_CONSTANT
using Polymers.Physics.SingleChain: ONE, ZERO, POINTS, integrate, parameters
using Polymers.Physics.SingleChain.Efjc.Thermodynamics.Isotensional: EFJC
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::nondimensional::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
residual_abs = end_to_end_length / link_length - nondimensional_end_to_end_length
residual_rel = residual_abs / nondimensional_end_to_end_length
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::nondimensional::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
residual_abs =
end_to_end_length_per_link / link_length -
nondimensional_end_to_end_length_per_link
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::nondimensional::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
residual_abs =
gibbs_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_gibbs_free_energy
residual_rel = residual_abs / nondimensional_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::nondimensional::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
residual_abs =
gibbs_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::nondimensional::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
residual_abs =
relative_gibbs_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_gibbs_free_energy
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::nondimensional::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
residual_abs =
relative_gibbs_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::per_link::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
residual_abs = end_to_end_length / number_of_links - end_to_end_length_per_link
residual_rel = residual_abs / end_to_end_length_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::per_link::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_end_to_end_length / number_of_links -
nondimensional_end_to_end_length_per_link
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::per_link::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
residual_abs = gibbs_free_energy / number_of_links - gibbs_free_energy_per_link
residual_rel = residual_abs / gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::per_link::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
residual_abs =
relative_gibbs_free_energy / number_of_links -
relative_gibbs_free_energy_per_link
residual_rel = residual_abs / relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::per_link::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_gibbs_free_energy / number_of_links -
nondimensional_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::per_link::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_relative_gibbs_free_energy / number_of_links -
nondimensional_relative_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::relative::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
gibbs_free_energy_0 = model.gibbs_free_energy(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
residual_abs = gibbs_free_energy - gibbs_free_energy_0 - relative_gibbs_free_energy
residual_rel = residual_abs / gibbs_free_energy_0
@test abs(residual_abs) <=
BOLTZMANN_CONSTANT * temperature * number_of_links * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::relative::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
gibbs_free_energy_per_link_0 = model.gibbs_free_energy_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
residual_abs =
gibbs_free_energy_per_link - gibbs_free_energy_per_link_0 -
relative_gibbs_free_energy_per_link
residual_rel = residual_abs / gibbs_free_energy_per_link_0
@test abs(residual_abs) <= BOLTZMANN_CONSTANT * temperature * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::relative::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
nondimensional_gibbs_free_energy_0 =
model.nondimensional_gibbs_free_energy(ZERO, temperature)
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_gibbs_free_energy - nondimensional_gibbs_free_energy_0 -
nondimensional_relative_gibbs_free_energy
residual_rel = residual_abs / nondimensional_gibbs_free_energy_0
@test abs(residual_abs) <= number_of_links * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::relative::nondimensional_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_gibbs_free_energy_per_link_0 =
model.nondimensional_gibbs_free_energy_per_link(ZERO, temperature)
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_gibbs_free_energy_per_link -
nondimensional_gibbs_free_energy_per_link_0 -
nondimensional_relative_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link_0
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::zero::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_gibbs_free_energy_0 = model.relative_gibbs_free_energy(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
@test abs(relative_gibbs_free_energy_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::zero::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_gibbs_free_energy_per_link_0 = model.relative_gibbs_free_energy_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
@test abs(relative_gibbs_free_energy_per_link_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::zero::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy_0 =
model.nondimensional_relative_gibbs_free_energy(ZERO, temperature)
@test abs(nondimensional_relative_gibbs_free_energy_0) <= ZERO * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::zero::nondimensional_relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy_per_link_0 =
model.nondimensional_relative_gibbs_free_energy_per_link(ZERO, temperature)
@test abs(nondimensional_relative_gibbs_free_energy_per_link_0) <= ZERO
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::connection::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
h = parameters.rel_tol * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_from_derivative =
-(
model.relative_gibbs_free_energy(force + 0.5 * h, temperature) -
model.relative_gibbs_free_energy(force - 0.5 * h, temperature)
) / h
residual_abs = end_to_end_length - end_to_end_length_from_derivative
residual_rel = residual_abs / end_to_end_length
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::connection::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
h = parameters.rel_tol * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link_from_derivative =
-(
model.relative_gibbs_free_energy_per_link(force + 0.5 * h, temperature) -
model.relative_gibbs_free_energy_per_link(force - 0.5 * h, temperature)
) / h
residual_abs =
end_to_end_length_per_link - end_to_end_length_per_link_from_derivative
residual_rel = residual_abs / end_to_end_length_per_link
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::connection::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
h = parameters.rel_tol
nondimensional_end_to_end_length_from_derivative =
-(
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force + 0.5 * h,
temperature,
) - model.nondimensional_relative_gibbs_free_energy(
nondimensional_force - 0.5 * h,
temperature,
)
) / h
residual_abs =
nondimensional_end_to_end_length -
nondimensional_end_to_end_length_from_derivative
residual_rel = residual_abs / nondimensional_end_to_end_length
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::connection::nondimensional_end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
h = parameters.rel_tol
nondimensional_end_to_end_length_per_link_from_derivative =
-(
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force + 0.5 * h,
temperature,
) - model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force - 0.5 * h,
temperature,
)
) / h
residual_abs =
nondimensional_end_to_end_length_per_link -
nondimensional_end_to_end_length_per_link_from_derivative
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::legendre::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
gibbs_free_energy_legendre =
model.legendre.helmholtz_free_energy(force, temperature) -
force * end_to_end_length
residual_abs = gibbs_free_energy - gibbs_free_energy_legendre
residual_rel = residual_abs / gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::legendre::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
gibbs_free_energy_per_link_legendre =
model.legendre.helmholtz_free_energy_per_link(force, temperature) -
force * end_to_end_length_per_link
residual_abs = gibbs_free_energy_per_link - gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::legendre::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
end_to_end_length_0 = model.end_to_end_length(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
relative_gibbs_free_energy_legendre =
model.legendre.relative_helmholtz_free_energy(force, temperature) -
force * end_to_end_length +
ZERO * BOLTZMANN_CONSTANT * temperature / link_length * end_to_end_length_0
residual_abs = relative_gibbs_free_energy - relative_gibbs_free_energy_legendre
residual_rel = residual_abs / relative_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::legendre::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
end_to_end_length_per_link_0 = model.end_to_end_length_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
relative_gibbs_free_energy_per_link_legendre =
model.legendre.relative_helmholtz_free_energy_per_link(force, temperature) -
force * end_to_end_length_per_link +
ZERO * BOLTZMANN_CONSTANT * temperature / link_length *
end_to_end_length_per_link_0
residual_abs =
relative_gibbs_free_energy_per_link -
relative_gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::legendre::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
nondimensional_gibbs_free_energy_legendre =
model.legendre.nondimensional_helmholtz_free_energy(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length
residual_abs =
nondimensional_gibbs_free_energy - nondimensional_gibbs_free_energy_legendre
residual_rel = residual_abs / nondimensional_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::legendre::nondimensional_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_gibbs_free_energy_per_link_legendre =
model.legendre.nondimensional_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length_per_link
residual_abs =
nondimensional_gibbs_free_energy_per_link -
nondimensional_gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::legendre::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
nondimensional_end_to_end_length_0 =
model.nondimensional_end_to_end_length(ZERO, temperature)
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
nondimensional_relative_gibbs_free_energy_legendre =
model.legendre.nondimensional_relative_helmholtz_free_energy(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length +
ZERO * nondimensional_end_to_end_length_0
residual_abs =
nondimensional_relative_gibbs_free_energy -
nondimensional_relative_gibbs_free_energy_legendre
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::legendre::nondimensional_relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_end_to_end_length_per_link_0 =
model.nondimensional_end_to_end_length_per_link(ZERO, temperature)
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_relative_gibbs_free_energy_per_link_legendre =
model.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length_per_link +
ZERO * nondimensional_end_to_end_length_per_link_0
residual_abs =
nondimensional_relative_gibbs_free_energy_per_link -
nondimensional_relative_gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::legendre_connection::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
h = parameters.rel_tol * BOLTZMANN_CONSTANT * temperature / link_length
force_from_derivative =
(
model.legendre.relative_helmholtz_free_energy(
force + 0.5 * h,
temperature,
) -
model.legendre.relative_helmholtz_free_energy(force - 0.5 * h, temperature)
) / (
model.end_to_end_length(force + 0.5 * h, temperature) -
model.end_to_end_length(force - 0.5 * h, temperature)
)
residual_abs = force - force_from_derivative
residual_rel = residual_abs / force
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::legendre_connection::nondimensional_force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
h = parameters.rel_tol
nondimensional_force_from_derivative =
(
model.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force + 0.5 * h,
temperature,
) - model.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force - 0.5 * h,
temperature,
)
) / (
model.nondimensional_end_to_end_length_per_link(
nondimensional_force + 0.5 * h,
temperature,
) - model.nondimensional_end_to_end_length_per_link(
nondimensional_force - 0.5 * h,
temperature,
)
)
residual_abs = nondimensional_force - nondimensional_force_from_derivative
residual_rel = residual_abs / nondimensional_force
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.end_to_end_length(force, temperature) -
model.asymptotic.end_to_end_length(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.end_to_end_length(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_medium)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_medium * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <=
exp(-parameters.nondimensional_link_stiffness_medium) &&
abs(residual_rel_2) <= exp(
-parameters.nondimensional_link_stiffness_medium *
parameters.log_log_scale,
) &&
log_log_slope < -2.0
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.end_to_end_length_per_link(force, temperature) -
model.asymptotic.end_to_end_length_per_link(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.end_to_end_length_per_link(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_medium)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_medium * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <=
exp(-parameters.nondimensional_link_stiffness_medium) &&
abs(residual_rel_2) <= exp(
-parameters.nondimensional_link_stiffness_medium *
parameters.log_log_scale,
) &&
log_log_slope < -2.0
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
) - model.asymptotic.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_medium)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_medium * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <=
exp(-parameters.nondimensional_link_stiffness_medium) &&
abs(residual_rel_2) <= exp(
-parameters.nondimensional_link_stiffness_medium *
parameters.log_log_scale,
) &&
log_log_slope < -2.0
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic::nondimensional_end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
) - model.asymptotic.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_medium)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_medium * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <=
exp(-parameters.nondimensional_link_stiffness_medium) &&
abs(residual_rel_2) <= exp(
-parameters.nondimensional_link_stiffness_medium *
parameters.log_log_scale,
) &&
log_log_slope < -2.0
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.gibbs_free_energy(force, temperature) -
model.asymptotic.gibbs_free_energy(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.gibbs_free_energy(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_medium)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_medium * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <=
exp(-parameters.nondimensional_link_stiffness_medium) &&
abs(residual_rel_2) <= exp(
-parameters.nondimensional_link_stiffness_medium *
parameters.log_log_scale,
) &&
log_log_slope < -2.0
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.gibbs_free_energy_per_link(force, temperature) -
model.asymptotic.gibbs_free_energy_per_link(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.gibbs_free_energy_per_link(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_medium)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_medium * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <=
exp(-parameters.nondimensional_link_stiffness_medium) &&
abs(residual_rel_2) <= exp(
-parameters.nondimensional_link_stiffness_medium *
parameters.log_log_scale,
) &&
log_log_slope < -2.0
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.relative_gibbs_free_energy(force, temperature) -
model.asymptotic.relative_gibbs_free_energy(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.relative_gibbs_free_energy(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_medium)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_medium * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <=
exp(-parameters.nondimensional_link_stiffness_medium) &&
abs(residual_rel_2) <= exp(
-parameters.nondimensional_link_stiffness_medium *
parameters.log_log_scale,
) &&
log_log_slope < -2.0
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.relative_gibbs_free_energy_per_link(force, temperature) -
model.asymptotic.relative_gibbs_free_energy_per_link(
force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.relative_gibbs_free_energy_per_link(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_medium)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_medium * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <=
exp(-parameters.nondimensional_link_stiffness_medium) &&
abs(residual_rel_2) <= exp(
-parameters.nondimensional_link_stiffness_medium *
parameters.log_log_scale,
) &&
log_log_slope < -2.0
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_gibbs_free_energy(
nondimensional_force,
temperature,
) - model.asymptotic.nondimensional_gibbs_free_energy(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_gibbs_free_energy(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_medium)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_medium * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <=
exp(-parameters.nondimensional_link_stiffness_medium) &&
abs(residual_rel_2) <= exp(
-parameters.nondimensional_link_stiffness_medium *
parameters.log_log_scale,
) &&
log_log_slope < -2.0
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic::nondimensional_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
) - model.asymptotic.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_medium)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_medium * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <=
exp(-parameters.nondimensional_link_stiffness_medium) &&
abs(residual_rel_2) <= exp(
-parameters.nondimensional_link_stiffness_medium *
parameters.log_log_scale,
) &&
log_log_slope < -2.0
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
) - model.asymptotic.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_medium)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_medium * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <=
exp(-parameters.nondimensional_link_stiffness_medium) &&
abs(residual_rel_2) <= exp(
-parameters.nondimensional_link_stiffness_medium *
parameters.log_log_scale,
) &&
log_log_slope < -2.0
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic::nondimensional_relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
) -
model.asymptotic.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_medium)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_medium * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <=
exp(-parameters.nondimensional_link_stiffness_medium) &&
abs(residual_rel_2) <= exp(
-parameters.nondimensional_link_stiffness_medium *
parameters.log_log_scale,
) &&
log_log_slope < -2.0
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic_reduced::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.end_to_end_length(force, temperature) -
model.asymptotic.reduced.end_to_end_length(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.end_to_end_length(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_big)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_big * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 5.0 / parameters.nondimensional_link_stiffness_big &&
abs(residual_rel_1) <=
5.0 / parameters.nondimensional_link_stiffness_big /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic_reduced::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.end_to_end_length_per_link(force, temperature) -
model.asymptotic.reduced.end_to_end_length_per_link(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.end_to_end_length_per_link(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_big)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_big * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 5.0 / parameters.nondimensional_link_stiffness_big &&
abs(residual_rel_1) <=
5.0 / parameters.nondimensional_link_stiffness_big /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic_reduced::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
) - model.asymptotic.reduced.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_big)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_big * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 5.0 / parameters.nondimensional_link_stiffness_big &&
abs(residual_rel_1) <=
5.0 / parameters.nondimensional_link_stiffness_big /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::test::asymptotic_reduced::nondimensional_end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
) - model.asymptotic.reduced.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_big)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_big * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 5.0 / parameters.nondimensional_link_stiffness_big &&
abs(residual_rel_1) <=
5.0 / parameters.nondimensional_link_stiffness_big /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 23513 | """
The extensible freely-jointed chain (EFJC) model thermodynamics in the isotensional ensemble approximated using an asymptotic approach.
"""
module Asymptotic
using DocStringExtensions
using .......Polymers: PROJECT_ROOT
import ......Physics: BOLTZMANN_CONSTANT
include("alternative/mod.jl")
include("reduced/mod.jl")
include("legendre/mod.jl")
"""
The structure of the thermodynamics of the EFJC model in the isotensional ensemble approximated using an asymptotic approach.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The thermodynamic functions of the model in the isotensional ensemble approximated using an alternative asymptotic approach.
"""
alternative::Any
"""
The thermodynamic functions of the model in the isotensional ensemble approximated using a reduced asymptotic approach.
"""
reduced::Any
"""
The thermodynamic functions of the model in the isotensional ensemble approximated using an asymptotic approach and a Legendre transformation.
"""
legendre::Any
"""
The expected end-to-end length ``\\xi`` as a function of the applied force ``f`` and temperature ``T``.
"""
end_to_end_length::Function
"""
The expected end-to-end length per link ``\\xi/N_b=\\ell_b\\gamma`` as a function of the applied force ``f`` and temperature ``T``.
"""
end_to_end_length_per_link::Function
"""
The expected nondimensional end-to-end length ``N_b\\gamma=\\xi/\\ell_b`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_end_to_end_length::Function
"""
The expected nondimensional end-to-end length per link ``\\gamma\\equiv\\xi/N_b\\ell_b`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_end_to_end_length_per_link::Function
"""
The Gibbs free energy ``\\varphi`` as a function of the applied force ``f`` and temperature ``T``.
"""
gibbs_free_energy::Function
"""
The Gibbs free energy per link ``\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``.
"""
gibbs_free_energy_per_link::Function
"""
The relative Gibbs free energy ``\\Delta\\varphi\\equiv\\varphi(f,T)-\\varphi(0,T)`` as a function of the applied force ``f`` and temperature ``T``.
"""
relative_gibbs_free_energy::Function
"""
The relative Gibbs free energy per link ``\\Delta\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``.
"""
relative_gibbs_free_energy_per_link::Function
"""
The nondimensional Gibbs free energy ``N_b\\varrho=\\beta\\varphi`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``.
"""
nondimensional_gibbs_free_energy::Function
"""
The nondimensional Gibbs free energy per link ``\\varrho\\equiv\\beta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``.
"""
nondimensional_gibbs_free_energy_per_link::Function
"""
The nondimensional relative Gibbs free energy ``N_b\\Delta\\varrho=\\beta\\Delta\\varphi`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_relative_gibbs_free_energy::Function
"""
The nondimensional relative Gibbs free energy per link ``\\Delta\\varrho\\equiv\\beta\\Delta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_relative_gibbs_free_energy_per_link::Function
end
"""
The expected end-to-end length ``N_b\\gamma=\\xi/\\ell_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``,
```math
\\xi(f, T) = -\\frac{\\partial\\varphi}{\\partial f}.
```
$(TYPEDSIGNATURES)
"""
function end_to_end_length(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, link_length_i, link_stiffness_i, force_i, temperature_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_end_to_end_length,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The expected end-to-end length per link ``\\xi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b`` and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function end_to_end_length_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_end_to_end_length_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64),
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The expected nondimensional end-to-end length ``N_b\\gamma=\\xi/\\ell_b`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the number of links ``N_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_end_to_end_length(
number_of_links::Union{UInt8,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, nondimensional_link_stiffness_i, nondimensional_force_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_nondimensional_end_to_end_length,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64),
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
number_of_links,
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
The expected nondimensional end-to-end length per link ``\\gamma\\equiv \\xi/N_b\\ell_b`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``,
given by [Radiom and Borkovec](https://doi.org/10.1103/PhysRevE.96.062501), [Fiasconaro and Falo](https://doi.org/10.1016/j.physa.2019.121929), [Buche and Silberstein](), [Buche et al.](https://doi.org/10.1103/PhysRevE.106.024502) as
```math
\\gamma(\\eta) \\sim \\mathcal{L}(\\eta) + \\frac{\\eta}{\\kappa}\\left[1 + \\frac{1 - \\mathcal{L}(\\eta)\\coth(\\eta)}{1 + (\\eta/\\kappa)\\coth(\\eta)}\\right] \\quad \\text{for } \\kappa\\gg 1,
```
where ``\\mathcal{L}(x)=\\coth(x)-1/x`` is the Langevin function.
$(TYPEDSIGNATURES)
"""
function nondimensional_end_to_end_length_per_link(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_force_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_nondimensional_end_to_end_length_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
The Gibbs free energy ``\\varphi`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, hinge mass ``m``, and link stiffness ``k_0``.
```math
\\varphi(f, T) = -kT\\ln Z(f, T).
```
$(TYPEDSIGNATURES)
"""
function gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
)
end
"""
The Gibbs free energy per link ``\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b``, hinge mass ``m``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function gibbs_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, hinge_mass_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64, Float64),
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
)
end
"""
The relative Gibbs free energy ``\\Delta\\varphi\\equiv\\varphi(f,T)-\\varphi(0,T)`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, link_length_i, link_stiffness_i, force_i, temperature_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_relative_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The relative Gibbs free energy per link ``\\Delta\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b`` and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_gibbs_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_relative_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64),
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The nondimensional Gibbs free energy ``N_b\\varrho=\\beta\\varphi`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, hinge mass ``m``, and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_nondimensional_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_force,
temperature,
)
end
"""
The nondimensional Gibbs free energy per link ``\\varrho\\equiv\\beta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``,
parameterized by the link length ``\\ell_b``, hinge mass ``m``, and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_gibbs_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_nondimensional_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64, Float64),
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
),
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_force,
temperature,
)
end
"""
The nondimensional relative Gibbs free energy ``N_b\\Delta\\varrho=\\beta\\Delta\\varphi`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the number of links ``N_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, nondimensional_link_stiffness_i, nondimensional_force_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_nondimensional_relative_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64),
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
number_of_links,
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
The nondimensional relative Gibbs free energy per link ``\\Delta\\varrho\\equiv\\beta\\Delta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``,
given by [Fiasconaro and Falo](https://doi.org/10.1016/j.physa.2019.121929), [Buche et al.](https://doi.org/10.1103/PhysRevE.106.024502) as
```math
\\Delta\\varrho(\\eta) = \\ln\\left[\\frac{\\eta}{\\sinh(\\eta)}\\right] - \\frac{\\eta^2}{2\\kappa} - \\ln\\left[1 + \\frac{\\eta}{\\kappa}\\,\\coth(\\eta)\\right] \\quad \\text{for } \\kappa\\gg 1.
```
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_force_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_nondimensional_relative_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
Initializes and returns an instance of the thermodynamics of the EFJC model in the isotensional ensemble approximated using an asymptotic approach.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
BOLTZMANN_CONSTANT::Float64 = 8.314462618
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
Alternative.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
Reduced.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
Legendre.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
(force, temperature) -> end_to_end_length(
number_of_links,
link_length,
link_stiffness,
force,
temperature,
),
(force, temperature) ->
end_to_end_length_per_link(link_length, link_stiffness, force, temperature),
(nondimensional_force, temperature) -> nondimensional_end_to_end_length(
number_of_links,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
(nondimensional_force, temperature) -> nondimensional_end_to_end_length_per_link(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
(force, temperature) -> gibbs_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
),
(force, temperature) -> gibbs_free_energy_per_link(
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
),
(force, temperature) -> relative_gibbs_free_energy(
number_of_links,
link_length,
link_stiffness,
force,
temperature,
),
(force, temperature) -> relative_gibbs_free_energy_per_link(
link_length,
link_stiffness,
force,
temperature,
),
(nondimensional_force, temperature) -> nondimensional_gibbs_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
temperature,
),
(nondimensional_force, temperature) -> nondimensional_gibbs_free_energy_per_link(
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
temperature,
),
(nondimensional_force, temperature) -> nondimensional_relative_gibbs_free_energy(
number_of_links,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
(nondimensional_force, temperature) ->
nondimensional_relative_gibbs_free_energy_per_link(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 129601 | module Test
using Test
using Polymers.Physics: BOLTZMANN_CONSTANT
using Polymers.Physics.SingleChain: ONE, ZERO, POINTS, integrate, parameters
using Polymers.Physics.SingleChain.Efjc.Thermodynamics.Isotensional.Asymptotic: EFJC
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::nondimensional::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
residual_abs = end_to_end_length / link_length - nondimensional_end_to_end_length
residual_rel = residual_abs / nondimensional_end_to_end_length
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::nondimensional::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
residual_abs =
end_to_end_length_per_link / link_length -
nondimensional_end_to_end_length_per_link
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::nondimensional::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
residual_abs =
gibbs_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_gibbs_free_energy
residual_rel = residual_abs / nondimensional_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::nondimensional::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
residual_abs =
gibbs_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::nondimensional::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
residual_abs =
relative_gibbs_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_gibbs_free_energy
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::nondimensional::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
residual_abs =
relative_gibbs_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::per_link::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
residual_abs = end_to_end_length / number_of_links - end_to_end_length_per_link
residual_rel = residual_abs / end_to_end_length_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::per_link::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_end_to_end_length / number_of_links -
nondimensional_end_to_end_length_per_link
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::per_link::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
residual_abs = gibbs_free_energy / number_of_links - gibbs_free_energy_per_link
residual_rel = residual_abs / gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::per_link::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
residual_abs =
relative_gibbs_free_energy / number_of_links -
relative_gibbs_free_energy_per_link
residual_rel = residual_abs / relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::per_link::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_gibbs_free_energy / number_of_links -
nondimensional_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::per_link::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_relative_gibbs_free_energy / number_of_links -
nondimensional_relative_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::relative::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
gibbs_free_energy_0 = model.gibbs_free_energy(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
residual_abs = gibbs_free_energy - gibbs_free_energy_0 - relative_gibbs_free_energy
residual_rel = residual_abs / gibbs_free_energy_0
@test abs(residual_abs) <=
BOLTZMANN_CONSTANT * temperature * number_of_links * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::relative::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
gibbs_free_energy_per_link_0 = model.gibbs_free_energy_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
residual_abs =
gibbs_free_energy_per_link - gibbs_free_energy_per_link_0 -
relative_gibbs_free_energy_per_link
residual_rel = residual_abs / gibbs_free_energy_per_link_0
@test abs(residual_abs) <= BOLTZMANN_CONSTANT * temperature * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::relative::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
nondimensional_gibbs_free_energy_0 =
model.nondimensional_gibbs_free_energy(ZERO, temperature)
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_gibbs_free_energy - nondimensional_gibbs_free_energy_0 -
nondimensional_relative_gibbs_free_energy
residual_rel = residual_abs / nondimensional_gibbs_free_energy_0
@test abs(residual_abs) <= number_of_links * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::relative::nondimensional_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_gibbs_free_energy_per_link_0 =
model.nondimensional_gibbs_free_energy_per_link(ZERO, temperature)
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_gibbs_free_energy_per_link -
nondimensional_gibbs_free_energy_per_link_0 -
nondimensional_relative_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link_0
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::zero::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_gibbs_free_energy_0 = model.relative_gibbs_free_energy(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
@test abs(relative_gibbs_free_energy_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::zero::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_gibbs_free_energy_per_link_0 = model.relative_gibbs_free_energy_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
@test abs(relative_gibbs_free_energy_per_link_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::zero::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy_0 =
model.nondimensional_relative_gibbs_free_energy(ZERO, temperature)
@test abs(nondimensional_relative_gibbs_free_energy_0) <= ZERO * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::zero::nondimensional_relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy_per_link_0 =
model.nondimensional_relative_gibbs_free_energy_per_link(ZERO, temperature)
@test abs(nondimensional_relative_gibbs_free_energy_per_link_0) <= ZERO
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::connection::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
h = parameters.rel_tol * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_from_derivative =
-(
model.relative_gibbs_free_energy(force + 0.5 * h, temperature) -
model.relative_gibbs_free_energy(force - 0.5 * h, temperature)
) / h
residual_abs = end_to_end_length - end_to_end_length_from_derivative
residual_rel = residual_abs / end_to_end_length
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::connection::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
h = parameters.rel_tol * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link_from_derivative =
-(
model.relative_gibbs_free_energy_per_link(force + 0.5 * h, temperature) -
model.relative_gibbs_free_energy_per_link(force - 0.5 * h, temperature)
) / h
residual_abs =
end_to_end_length_per_link - end_to_end_length_per_link_from_derivative
residual_rel = residual_abs / end_to_end_length_per_link
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::connection::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
h = parameters.rel_tol
nondimensional_end_to_end_length_from_derivative =
-(
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force + 0.5 * h,
temperature,
) - model.nondimensional_relative_gibbs_free_energy(
nondimensional_force - 0.5 * h,
temperature,
)
) / h
residual_abs =
nondimensional_end_to_end_length -
nondimensional_end_to_end_length_from_derivative
residual_rel = residual_abs / nondimensional_end_to_end_length
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::connection::nondimensional_end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
h = parameters.rel_tol
nondimensional_end_to_end_length_per_link_from_derivative =
-(
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force + 0.5 * h,
temperature,
) - model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force - 0.5 * h,
temperature,
)
) / h
residual_abs =
nondimensional_end_to_end_length_per_link -
nondimensional_end_to_end_length_per_link_from_derivative
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::legendre::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
gibbs_free_energy_legendre =
model.legendre.helmholtz_free_energy(force, temperature) -
force * end_to_end_length
residual_abs = gibbs_free_energy - gibbs_free_energy_legendre
residual_rel = residual_abs / gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::legendre::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
gibbs_free_energy_per_link_legendre =
model.legendre.helmholtz_free_energy_per_link(force, temperature) -
force * end_to_end_length_per_link
residual_abs = gibbs_free_energy_per_link - gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::legendre::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
end_to_end_length_0 = model.end_to_end_length(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
relative_gibbs_free_energy_legendre =
model.legendre.relative_helmholtz_free_energy(force, temperature) -
force * end_to_end_length +
ZERO * BOLTZMANN_CONSTANT * temperature / link_length * end_to_end_length_0
residual_abs = relative_gibbs_free_energy - relative_gibbs_free_energy_legendre
residual_rel = residual_abs / relative_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::legendre::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
end_to_end_length_per_link_0 = model.end_to_end_length_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
relative_gibbs_free_energy_per_link_legendre =
model.legendre.relative_helmholtz_free_energy_per_link(force, temperature) -
force * end_to_end_length_per_link +
ZERO * BOLTZMANN_CONSTANT * temperature / link_length *
end_to_end_length_per_link_0
residual_abs =
relative_gibbs_free_energy_per_link -
relative_gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::legendre::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
nondimensional_gibbs_free_energy_legendre =
model.legendre.nondimensional_helmholtz_free_energy(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length
residual_abs =
nondimensional_gibbs_free_energy - nondimensional_gibbs_free_energy_legendre
residual_rel = residual_abs / nondimensional_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::legendre::nondimensional_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_gibbs_free_energy_per_link_legendre =
model.legendre.nondimensional_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length_per_link
residual_abs =
nondimensional_gibbs_free_energy_per_link -
nondimensional_gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::legendre::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
nondimensional_end_to_end_length_0 =
model.nondimensional_end_to_end_length(ZERO, temperature)
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
nondimensional_relative_gibbs_free_energy_legendre =
model.legendre.nondimensional_relative_helmholtz_free_energy(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length +
ZERO * nondimensional_end_to_end_length_0
residual_abs =
nondimensional_relative_gibbs_free_energy -
nondimensional_relative_gibbs_free_energy_legendre
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::legendre::nondimensional_relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_end_to_end_length_per_link_0 =
model.nondimensional_end_to_end_length_per_link(ZERO, temperature)
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_relative_gibbs_free_energy_per_link_legendre =
model.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length_per_link +
ZERO * nondimensional_end_to_end_length_per_link_0
residual_abs =
nondimensional_relative_gibbs_free_energy_per_link -
nondimensional_relative_gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::legendre_connection::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
h = parameters.rel_tol * BOLTZMANN_CONSTANT * temperature / link_length
force_from_derivative =
(
model.legendre.relative_helmholtz_free_energy(
force + 0.5 * h,
temperature,
) -
model.legendre.relative_helmholtz_free_energy(force - 0.5 * h, temperature)
) / (
model.end_to_end_length(force + 0.5 * h, temperature) -
model.end_to_end_length(force - 0.5 * h, temperature)
)
residual_abs = force - force_from_derivative
residual_rel = residual_abs / force
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::legendre_connection::nondimensional_force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
h = parameters.rel_tol
nondimensional_force_from_derivative =
(
model.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force + 0.5 * h,
temperature,
) - model.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force - 0.5 * h,
temperature,
)
) / (
model.nondimensional_end_to_end_length_per_link(
nondimensional_force + 0.5 * h,
temperature,
) - model.nondimensional_end_to_end_length_per_link(
nondimensional_force - 0.5 * h,
temperature,
)
)
residual_abs = nondimensional_force - nondimensional_force_from_derivative
residual_rel = residual_abs / nondimensional_force
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_reduced::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.end_to_end_length(force, temperature) -
model.reduced.end_to_end_length(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.end_to_end_length(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_reduced::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.end_to_end_length_per_link(force, temperature) -
model.reduced.end_to_end_length_per_link(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.end_to_end_length_per_link(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_reduced::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
) - model.reduced.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_reduced::nondimensional_end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
) - model.reduced.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_reduced::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.gibbs_free_energy(force, temperature) -
model.reduced.gibbs_free_energy(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.gibbs_free_energy(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_reduced::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.gibbs_free_energy_per_link(force, temperature) -
model.reduced.gibbs_free_energy_per_link(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.gibbs_free_energy_per_link(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_reduced::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.relative_gibbs_free_energy(force, temperature) -
model.reduced.relative_gibbs_free_energy(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.relative_gibbs_free_energy(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_reduced::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.relative_gibbs_free_energy_per_link(force, temperature) -
model.reduced.relative_gibbs_free_energy_per_link(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.relative_gibbs_free_energy_per_link(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_reduced::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_gibbs_free_energy(
nondimensional_force,
temperature,
) - model.reduced.nondimensional_gibbs_free_energy(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_gibbs_free_energy(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_reduced::nondimensional_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
) - model.reduced.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_reduced::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
) - model.reduced.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_reduced::nondimensional_relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
) - model.reduced.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_alternative::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.end_to_end_length(force, temperature) -
model.alternative.end_to_end_length(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.end_to_end_length(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(0.5 * log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_alternative::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.end_to_end_length_per_link(force, temperature) -
model.alternative.end_to_end_length_per_link(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.end_to_end_length_per_link(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(0.5 * log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_alternative::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
) - model.alternative.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_end_to_end_length(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(0.5 * log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_alternative::nondimensional_end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
) - model.alternative.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(0.5 * log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_alternative::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.gibbs_free_energy(force, temperature) -
model.alternative.gibbs_free_energy(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.gibbs_free_energy(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(0.5 * log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_alternative::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.gibbs_free_energy_per_link(force, temperature) -
model.alternative.gibbs_free_energy_per_link(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.gibbs_free_energy_per_link(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(0.5 * log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_alternative::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.relative_gibbs_free_energy(force, temperature) -
model.alternative.relative_gibbs_free_energy(force, temperature)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.relative_gibbs_free_energy(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(0.5 * log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_alternative::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return (
model.relative_gibbs_free_energy_per_link(force, temperature) -
model.alternative.relative_gibbs_free_energy_per_link(
force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
force =
nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
return model.relative_gibbs_free_energy_per_link(force, temperature)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(0.5 * log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_alternative::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_gibbs_free_energy(
nondimensional_force,
temperature,
) - model.alternative.nondimensional_gibbs_free_energy(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_gibbs_free_energy(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(0.5 * log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_alternative::nondimensional_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
) - model.alternative.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(0.5 * log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_alternative::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
) - model.alternative.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(0.5 * log_log_slope + 1.0) <= parameters.log_log_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::test::asymptotic_alternative::nondimensional_relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
function residual_rel(nondimensional_link_stiffness)
link_stiffness =
BOLTZMANN_CONSTANT * temperature / link_length^2 *
nondimensional_link_stiffness
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
function integrand_numerator(nondimensional_force)
return (
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
) -
model.alternative.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
)^2
end
function integrand_denominator(nondimensional_force)
return model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)^2
end
numerator = integrate(
integrand_numerator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
denominator = integrate(
integrand_denominator,
ZERO,
parameters.nondimensional_force_scale,
POINTS,
)
return sqrt(numerator / denominator)
end
residual_rel_1 = residual_rel(parameters.nondimensional_link_stiffness_large)
residual_rel_2 = residual_rel(
parameters.nondimensional_link_stiffness_large * parameters.log_log_scale,
)
log_log_slope = log(residual_rel_2 / residual_rel_1) / log(parameters.log_log_scale)
@test abs(residual_rel_1) <= 2.0 / parameters.nondimensional_link_stiffness_large &&
abs(residual_rel_2) <=
2.0 / parameters.nondimensional_link_stiffness_large /
parameters.log_log_scale &&
abs(0.5 * log_log_slope + 1.0) <= parameters.log_log_tol
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 22894 | """
The extensible freely-jointed chain (EFJC) model thermodynamics in the isotensional ensemble approximated using an alternative alternative asymptotic approach.
"""
module Alternative
using DocStringExtensions
using ........Polymers: PROJECT_ROOT
import .......Physics: BOLTZMANN_CONSTANT
include("legendre/mod.jl")
"""
The structure of the thermodynamics of the EFJC model in the isotensional ensemble approximated using an alternative alternative asymptotic approach.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The thermodynamic functions of the model in the isotensional ensemble approximated using an alternative alternative asymptotic approach.
"""
legendre::Any
"""
The expected end-to-end length ``\\xi`` as a function of the applied force ``f`` and temperature ``T``.
"""
end_to_end_length::Function
"""
The expected end-to-end length per link ``\\xi/N_b=\\ell_b\\gamma`` as a function of the applied force ``f`` and temperature ``T``.
"""
end_to_end_length_per_link::Function
"""
The expected nondimensional end-to-end length ``N_b\\gamma=\\xi/\\ell_b`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_end_to_end_length::Function
"""
The expected nondimensional end-to-end length per link ``\\gamma\\equiv\\xi/N_b\\ell_b`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_end_to_end_length_per_link::Function
"""
The Gibbs free energy ``\\varphi`` as a function of the applied force ``f`` and temperature ``T``.
"""
gibbs_free_energy::Function
"""
The Gibbs free energy per link ``\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``.
"""
gibbs_free_energy_per_link::Function
"""
The relative Gibbs free energy ``\\Delta\\varphi\\equiv\\varphi(f,T)-\\varphi(0,T)`` as a function of the applied force ``f`` and temperature ``T``.
"""
relative_gibbs_free_energy::Function
"""
The relative Gibbs free energy per link ``\\Delta\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``.
"""
relative_gibbs_free_energy_per_link::Function
"""
The nondimensional Gibbs free energy ``N_b\\varrho=\\beta\\varphi`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``.
"""
nondimensional_gibbs_free_energy::Function
"""
The nondimensional Gibbs free energy per link ``\\varrho\\equiv\\beta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``.
"""
nondimensional_gibbs_free_energy_per_link::Function
"""
The nondimensional relative Gibbs free energy ``N_b\\Delta\\varrho=\\beta\\Delta\\varphi`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_relative_gibbs_free_energy::Function
"""
The nondimensional relative Gibbs free energy per link ``\\Delta\\varrho\\equiv\\beta\\Delta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_relative_gibbs_free_energy_per_link::Function
end
"""
The expected end-to-end length ``N_b\\gamma=\\xi/\\ell_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``,
```math
\\xi(f, T) = -\\frac{\\partial\\varphi}{\\partial f}.
```
$(TYPEDSIGNATURES)
"""
function end_to_end_length(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, link_length_i, link_stiffness_i, force_i, temperature_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_end_to_end_length,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The expected end-to-end length per link ``\\xi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b`` and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function end_to_end_length_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_end_to_end_length_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64),
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The expected nondimensional end-to-end length ``N_b\\gamma=\\xi/\\ell_b`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the number of links ``N_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_end_to_end_length(
number_of_links::Union{UInt8,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, nondimensional_link_stiffness_i, nondimensional_force_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_nondimensional_end_to_end_length,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64),
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
number_of_links,
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
The expected nondimensional end-to-end length per link ``\\gamma\\equiv \\xi/N_b\\ell_b`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``,
calculated from [Buche et al.](https://doi.org/10.1103/PhysRevE.106.024502) as
```math
\\gamma(\\eta) \\sim \\mathcal{L}(\\eta) + \\frac{1}{\\kappa}\\left[\\eta + \\coth(\\eta) - \\eta\\csc^2(\\eta)\\right] \\quad \\text{for } \\kappa\\gg 1.
```
where ``\\mathcal{L}(x)=\\coth(x)-1/x`` is the Langevin function.
$(TYPEDSIGNATURES)
"""
function nondimensional_end_to_end_length_per_link(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_force_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_nondimensional_end_to_end_length_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
The Gibbs free energy ``\\varphi`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, hinge mass ``m``, and link stiffness ``k_0``.
```math
\\varphi(f, T) = -kT\\ln Z(f, T).
```
$(TYPEDSIGNATURES)
"""
function gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
)
end
"""
The Gibbs free energy per link ``\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b``, hinge mass ``m``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function gibbs_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, hinge_mass_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64, Float64),
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
)
end
"""
The relative Gibbs free energy ``\\Delta\\varphi\\equiv\\varphi(f,T)-\\varphi(0,T)`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, link_length_i, link_stiffness_i, force_i, temperature_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_relative_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The relative Gibbs free energy per link ``\\Delta\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b`` and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_gibbs_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_relative_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64),
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The nondimensional Gibbs free energy ``N_b\\varrho=\\beta\\varphi`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, hinge mass ``m``, and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_nondimensional_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_force,
temperature,
)
end
"""
The nondimensional Gibbs free energy per link ``\\varrho\\equiv\\beta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``,
parameterized by the link length ``\\ell_b``, hinge mass ``m``, and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_gibbs_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_nondimensional_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64, Float64),
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
),
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_force,
temperature,
)
end
"""
The nondimensional relative Gibbs free energy ``N_b\\Delta\\varrho=\\beta\\Delta\\varphi`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the number of links ``N_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, nondimensional_link_stiffness_i, nondimensional_force_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_nondimensional_relative_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64),
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
number_of_links,
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
The nondimensional relative Gibbs free energy per link ``\\Delta\\varrho\\equiv\\beta\\Delta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``,
given by [Buche et al.](https://doi.org/10.1103/PhysRevE.106.024502) as
```math
\\Delta\\varrho(\\eta) = \\ln\\left[\\frac{\\eta}{\\sinh(\\eta)}\\right] - \\frac{\\eta^2}{2\\kappa} - \\frac{\\eta}{\\kappa}\\,\\coth(\\eta) \\quad \\text{for } \\kappa\\gg 1.
```
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_force_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_nondimensional_relative_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
Initializes and returns an instance of the thermodynamics of the EFJC model in the isotensional ensemble approximated using an alternative alternative asymptotic approach.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
BOLTZMANN_CONSTANT::Float64 = 8.314462618
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
Legendre.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
(force, temperature) -> end_to_end_length(
number_of_links,
link_length,
link_stiffness,
force,
temperature,
),
(force, temperature) ->
end_to_end_length_per_link(link_length, link_stiffness, force, temperature),
(nondimensional_force, temperature) -> nondimensional_end_to_end_length(
number_of_links,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
(nondimensional_force, temperature) -> nondimensional_end_to_end_length_per_link(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
(force, temperature) -> gibbs_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
),
(force, temperature) -> gibbs_free_energy_per_link(
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
),
(force, temperature) -> relative_gibbs_free_energy(
number_of_links,
link_length,
link_stiffness,
force,
temperature,
),
(force, temperature) -> relative_gibbs_free_energy_per_link(
link_length,
link_stiffness,
force,
temperature,
),
(nondimensional_force, temperature) -> nondimensional_gibbs_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
temperature,
),
(nondimensional_force, temperature) -> nondimensional_gibbs_free_energy_per_link(
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
temperature,
),
(nondimensional_force, temperature) -> nondimensional_relative_gibbs_free_energy(
number_of_links,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
(nondimensional_force, temperature) ->
nondimensional_relative_gibbs_free_energy_per_link(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 63995 | module Test
using Test
using Polymers.Physics: BOLTZMANN_CONSTANT
using Polymers.Physics.SingleChain: ZERO, parameters
using Polymers.Physics.SingleChain.Efjc.Thermodynamics.Isotensional.Asymptotic.Alternative:
EFJC
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::nondimensional::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
residual_abs = end_to_end_length / link_length - nondimensional_end_to_end_length
residual_rel = residual_abs / nondimensional_end_to_end_length
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::nondimensional::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
residual_abs =
end_to_end_length_per_link / link_length -
nondimensional_end_to_end_length_per_link
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::nondimensional::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
residual_abs =
gibbs_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_gibbs_free_energy
residual_rel = residual_abs / nondimensional_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::nondimensional::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
residual_abs =
gibbs_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::nondimensional::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
residual_abs =
relative_gibbs_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_gibbs_free_energy
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::nondimensional::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
residual_abs =
relative_gibbs_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::per_link::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
residual_abs = end_to_end_length / number_of_links - end_to_end_length_per_link
residual_rel = residual_abs / end_to_end_length_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::per_link::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_end_to_end_length / number_of_links -
nondimensional_end_to_end_length_per_link
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::per_link::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
residual_abs = gibbs_free_energy / number_of_links - gibbs_free_energy_per_link
residual_rel = residual_abs / gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::per_link::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
residual_abs =
relative_gibbs_free_energy / number_of_links -
relative_gibbs_free_energy_per_link
residual_rel = residual_abs / relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::per_link::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_gibbs_free_energy / number_of_links -
nondimensional_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::per_link::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_relative_gibbs_free_energy / number_of_links -
nondimensional_relative_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::relative::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
gibbs_free_energy_0 = model.gibbs_free_energy(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
residual_abs = gibbs_free_energy - gibbs_free_energy_0 - relative_gibbs_free_energy
residual_rel = residual_abs / gibbs_free_energy_0
@test abs(residual_abs) <=
BOLTZMANN_CONSTANT * temperature * number_of_links * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::relative::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
gibbs_free_energy_per_link_0 = model.gibbs_free_energy_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
residual_abs =
gibbs_free_energy_per_link - gibbs_free_energy_per_link_0 -
relative_gibbs_free_energy_per_link
residual_rel = residual_abs / gibbs_free_energy_per_link_0
@test abs(residual_abs) <= BOLTZMANN_CONSTANT * temperature * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::relative::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
nondimensional_gibbs_free_energy_0 =
model.nondimensional_gibbs_free_energy(ZERO, temperature)
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_gibbs_free_energy - nondimensional_gibbs_free_energy_0 -
nondimensional_relative_gibbs_free_energy
residual_rel = residual_abs / nondimensional_gibbs_free_energy_0
@test abs(residual_abs) <= number_of_links * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::relative::nondimensional_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_gibbs_free_energy_per_link_0 =
model.nondimensional_gibbs_free_energy_per_link(ZERO, temperature)
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_gibbs_free_energy_per_link -
nondimensional_gibbs_free_energy_per_link_0 -
nondimensional_relative_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link_0
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::zero::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_gibbs_free_energy_0 = model.relative_gibbs_free_energy(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
@test abs(relative_gibbs_free_energy_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::zero::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_gibbs_free_energy_per_link_0 = model.relative_gibbs_free_energy_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
@test abs(relative_gibbs_free_energy_per_link_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::zero::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy_0 =
model.nondimensional_relative_gibbs_free_energy(ZERO, temperature)
@test abs(nondimensional_relative_gibbs_free_energy_0) <= ZERO * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::zero::nondimensional_relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy_per_link_0 =
model.nondimensional_relative_gibbs_free_energy_per_link(ZERO, temperature)
@test abs(nondimensional_relative_gibbs_free_energy_per_link_0) <= ZERO
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::connection::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
h = parameters.rel_tol * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_from_derivative =
-(
model.relative_gibbs_free_energy(force + 0.5 * h, temperature) -
model.relative_gibbs_free_energy(force - 0.5 * h, temperature)
) / h
residual_abs = end_to_end_length - end_to_end_length_from_derivative
residual_rel = residual_abs / end_to_end_length
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::connection::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
h = parameters.rel_tol * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link_from_derivative =
-(
model.relative_gibbs_free_energy_per_link(force + 0.5 * h, temperature) -
model.relative_gibbs_free_energy_per_link(force - 0.5 * h, temperature)
) / h
residual_abs =
end_to_end_length_per_link - end_to_end_length_per_link_from_derivative
residual_rel = residual_abs / end_to_end_length_per_link
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::connection::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
h = parameters.rel_tol
nondimensional_end_to_end_length_from_derivative =
-(
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force + 0.5 * h,
temperature,
) - model.nondimensional_relative_gibbs_free_energy(
nondimensional_force - 0.5 * h,
temperature,
)
) / h
residual_abs =
nondimensional_end_to_end_length -
nondimensional_end_to_end_length_from_derivative
residual_rel = residual_abs / nondimensional_end_to_end_length
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::connection::nondimensional_end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
h = parameters.rel_tol
nondimensional_end_to_end_length_per_link_from_derivative =
-(
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force + 0.5 * h,
temperature,
) - model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force - 0.5 * h,
temperature,
)
) / h
residual_abs =
nondimensional_end_to_end_length_per_link -
nondimensional_end_to_end_length_per_link_from_derivative
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::legendre::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
gibbs_free_energy_legendre =
model.legendre.helmholtz_free_energy(force, temperature) -
force * end_to_end_length
residual_abs = gibbs_free_energy - gibbs_free_energy_legendre
residual_rel = residual_abs / gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::legendre::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
gibbs_free_energy_per_link_legendre =
model.legendre.helmholtz_free_energy_per_link(force, temperature) -
force * end_to_end_length_per_link
residual_abs = gibbs_free_energy_per_link - gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::legendre::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
end_to_end_length_0 = model.end_to_end_length(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
relative_gibbs_free_energy_legendre =
model.legendre.relative_helmholtz_free_energy(force, temperature) -
force * end_to_end_length +
ZERO * BOLTZMANN_CONSTANT * temperature / link_length * end_to_end_length_0
residual_abs = relative_gibbs_free_energy - relative_gibbs_free_energy_legendre
residual_rel = residual_abs / relative_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::legendre::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
end_to_end_length_per_link_0 = model.end_to_end_length_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
relative_gibbs_free_energy_per_link_legendre =
model.legendre.relative_helmholtz_free_energy_per_link(force, temperature) -
force * end_to_end_length_per_link +
ZERO * BOLTZMANN_CONSTANT * temperature / link_length *
end_to_end_length_per_link_0
residual_abs =
relative_gibbs_free_energy_per_link -
relative_gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::legendre::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
nondimensional_gibbs_free_energy_legendre =
model.legendre.nondimensional_helmholtz_free_energy(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length
residual_abs =
nondimensional_gibbs_free_energy - nondimensional_gibbs_free_energy_legendre
residual_rel = residual_abs / nondimensional_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::legendre::nondimensional_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_gibbs_free_energy_per_link_legendre =
model.legendre.nondimensional_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length_per_link
residual_abs =
nondimensional_gibbs_free_energy_per_link -
nondimensional_gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::legendre::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
nondimensional_end_to_end_length_0 =
model.nondimensional_end_to_end_length(ZERO, temperature)
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
nondimensional_relative_gibbs_free_energy_legendre =
model.legendre.nondimensional_relative_helmholtz_free_energy(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length +
ZERO * nondimensional_end_to_end_length_0
residual_abs =
nondimensional_relative_gibbs_free_energy -
nondimensional_relative_gibbs_free_energy_legendre
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::legendre::nondimensional_relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_end_to_end_length_per_link_0 =
model.nondimensional_end_to_end_length_per_link(ZERO, temperature)
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_relative_gibbs_free_energy_per_link_legendre =
model.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length_per_link +
ZERO * nondimensional_end_to_end_length_per_link_0
residual_abs =
nondimensional_relative_gibbs_free_energy_per_link -
nondimensional_relative_gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::legendre_connection::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
h = parameters.rel_tol * BOLTZMANN_CONSTANT * temperature / link_length
force_from_derivative =
(
model.legendre.relative_helmholtz_free_energy(
force + 0.5 * h,
temperature,
) -
model.legendre.relative_helmholtz_free_energy(force - 0.5 * h, temperature)
) / (
model.end_to_end_length(force + 0.5 * h, temperature) -
model.end_to_end_length(force - 0.5 * h, temperature)
)
residual_abs = force - force_from_derivative
residual_rel = residual_abs / force
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::test::legendre_connection::nondimensional_force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
h = parameters.rel_tol
nondimensional_force_from_derivative =
(
model.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force + 0.5 * h,
temperature,
) - model.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force - 0.5 * h,
temperature,
)
) / (
model.nondimensional_end_to_end_length_per_link(
nondimensional_force + 0.5 * h,
temperature,
) - model.nondimensional_end_to_end_length_per_link(
nondimensional_force - 0.5 * h,
temperature,
)
)
residual_abs = nondimensional_force - nondimensional_force_from_derivative
residual_rel = residual_abs / nondimensional_force
@test abs(residual_rel) <= h
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 16122 | """
The extensible freely-jointed chain (EFJC) model thermodynamics in the isotensional ensemble approximated using a alternative asymptotic approach and a Legendre transformation.
"""
module Legendre
using DocStringExtensions
using .........Polymers: PROJECT_ROOT
import ........Physics: BOLTZMANN_CONSTANT
"""
The structure of the thermodynamics of the EFJC model in the isotensional ensemble approximated using a alternative asymptotic approach and a Legendre transformation.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The Helmholtz free energy ``\\psi`` as a function of the applied force ``f`` and temperature ``T``.
"""
helmholtz_free_energy::Function
"""
The Helmholtz free energy per link ``\\psi/N_b`` as a function of the applied force ``f`` and temperature ``T``.
"""
helmholtz_free_energy_per_link::Function
"""
The relative helmholtz free energy ``\\Delta\\psi\\equiv\\psi(f,T)-\\psi(0,T)`` as a function of the applied force ``f`` and temperature ``T``.
"""
relative_helmholtz_free_energy::Function
"""
The relative helmholtz free energy per link ``\\Delta\\psi/N_b`` as a function of the applied force ``f`` and temperature ``T``.
"""
relative_helmholtz_free_energy_per_link::Function
"""
The nondimensional helmholtz free energy ``N_b\\vartheta=\\beta\\psi`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``.
"""
nondimensional_helmholtz_free_energy::Function
"""
The nondimensional helmholtz free energy per link ``\\vartheta\\equiv\\beta\\psi/N_b`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``.
"""
nondimensional_helmholtz_free_energy_per_link::Function
"""
The nondimensional relative helmholtz free energy ``N_b\\Delta\\vartheta=\\beta\\Delta\\psi`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_relative_helmholtz_free_energy::Function
"""
The nondimensional relative helmholtz free energy per link ``\\Delta\\vartheta\\equiv\\beta\\Delta\\psi/N_b`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_relative_helmholtz_free_energy_per_link::Function
end
"""
The Helmholtz free energy ``\\psi`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, hinge mass ``m``, and link stiffness ``k_0``.
```math
\\psi(f, T) \\sim \\varphi(f, T) + f \\xi(f, T) \\quad \\text{for } N_b\\gg 1.
```
$(TYPEDSIGNATURES)
"""
function helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_legendre_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
)
end
"""
The Helmholtz free energy per link ``\\psi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b``, hinge mass ``m``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function helmholtz_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, hinge_mass_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_legendre_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64, Float64),
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
)
end
"""
The relative Helmholtz free energy ``\\Delta\\psi\\equiv\\psi(f,T)-\\psi(0,T)`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, link_length_i, link_stiffness_i, force_i, temperature_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_legendre_relative_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The relative Helmholtz free energy per link ``\\Delta\\psi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b`` and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_helmholtz_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_legendre_relative_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64),
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The nondimensional Helmholtz free energy ``N_b\\vartheta=\\beta\\psi`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, hinge mass ``m``, and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_legendre_nondimensional_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_force,
temperature,
)
end
"""
The nondimensional Helmholtz free energy per link ``\\vartheta\\equiv\\beta\\psi/N_b`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``,
parameterized by the link length ``\\ell_b``, hinge mass ``m``, and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_helmholtz_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_legendre_nondimensional_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64, Float64),
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
),
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_force,
temperature,
)
end
"""
The nondimensional relative Helmholtz free energy ``N_b\\Delta\\vartheta=\\beta\\Delta\\psi`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the number of links ``N_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, nondimensional_link_stiffness_i, nondimensional_force_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_legendre_nondimensional_relative_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64),
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
number_of_links,
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
The nondimensional relative Helmholtz free energy per link ``\\Delta\\vartheta\\equiv\\beta\\Delta\\psi/N_b`` as a function of the applied nondimensional force ``\\eta``
parameterized by the nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_force_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_alternative_legendre_nondimensional_relative_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
Initializes and returns an instance of the thermodynamics of the EFJC model in the isotensional ensemble approximated using a alternative asymptotic approach and a Legendre transformation.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
BOLTZMANN_CONSTANT::Float64 = 8.314462618
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
(force, temperature) -> helmholtz_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
),
(force, temperature) -> helmholtz_free_energy_per_link(
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
),
(force, temperature) -> relative_helmholtz_free_energy(
number_of_links,
link_length,
link_stiffness,
force,
temperature,
),
(force, temperature) -> relative_helmholtz_free_energy_per_link(
link_length,
link_stiffness,
force,
temperature,
),
(nondimensional_force, temperature) -> nondimensional_helmholtz_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
temperature,
),
(nondimensional_force, temperature) ->
nondimensional_helmholtz_free_energy_per_link(
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
temperature,
),
(nondimensional_force, temperature) ->
nondimensional_relative_helmholtz_free_energy(
number_of_links,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
(nondimensional_force, temperature) ->
nondimensional_relative_helmholtz_free_energy_per_link(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 30925 | module Test
using Test
using Polymers.Physics: BOLTZMANN_CONSTANT
using Polymers.Physics.SingleChain: ZERO, parameters
using Polymers.Physics.SingleChain.Efjc.Thermodynamics.Isotensional.Asymptotic.Alternative.Legendre:
EFJC
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::nondimensional::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy =
model.nondimensional_helmholtz_free_energy(nondimensional_force, temperature)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
helmholtz_free_energy = model.helmholtz_free_energy(force, temperature)
residual_abs =
helmholtz_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_helmholtz_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::nondimensional::helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(force, temperature)
residual_abs =
helmholtz_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::nondimensional::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(force, temperature)
residual_abs =
relative_helmholtz_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::nondimensional::relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(force, temperature)
residual_abs =
relative_helmholtz_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::per_link::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
helmholtz_free_energy = model.helmholtz_free_energy(force, temperature)
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(force, temperature)
residual_abs =
helmholtz_free_energy / number_of_links - helmholtz_free_energy_per_link
residual_rel = residual_abs / helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::per_link::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(force, temperature)
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(force, temperature)
residual_abs =
relative_helmholtz_free_energy / number_of_links -
relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::per_link::nondimensional_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy =
model.nondimensional_helmholtz_free_energy(nondimensional_force, temperature)
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy / number_of_links -
nondimensional_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::per_link::nondimensional_relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_force,
temperature,
)
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_relative_helmholtz_free_energy / number_of_links -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::relative::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
helmholtz_free_energy = model.helmholtz_free_energy(force, temperature)
helmholtz_free_energy_0 = model.helmholtz_free_energy(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(force, temperature)
residual_abs =
helmholtz_free_energy - helmholtz_free_energy_0 - relative_helmholtz_free_energy
residual_rel = residual_abs / helmholtz_free_energy_0
@test abs(residual_abs) <=
BOLTZMANN_CONSTANT * temperature * number_of_links * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::relative::helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(force, temperature)
helmholtz_free_energy_per_link_0 = model.helmholtz_free_energy_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(force, temperature)
residual_abs =
helmholtz_free_energy_per_link - helmholtz_free_energy_per_link_0 -
relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / helmholtz_free_energy_per_link_0
@test abs(residual_abs) <= BOLTZMANN_CONSTANT * temperature * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::relative::nondimensional_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy =
model.nondimensional_helmholtz_free_energy(nondimensional_force, temperature)
nondimensional_helmholtz_free_energy_0 =
model.nondimensional_helmholtz_free_energy(ZERO, temperature)
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy - nondimensional_helmholtz_free_energy_0 -
nondimensional_relative_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_0
@test abs(residual_abs) <= number_of_links * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::relative::nondimensional_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_helmholtz_free_energy_per_link_0 =
model.nondimensional_helmholtz_free_energy_per_link(ZERO, temperature)
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy_per_link -
nondimensional_helmholtz_free_energy_per_link_0 -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link_0
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::zero::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_helmholtz_free_energy_0 = model.relative_helmholtz_free_energy(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
@test abs(relative_helmholtz_free_energy_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::zero::relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_helmholtz_free_energy_per_link_0 =
model.relative_helmholtz_free_energy_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
@test abs(relative_helmholtz_free_energy_per_link_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::zero::nondimensional_relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_0 =
model.nondimensional_relative_helmholtz_free_energy(ZERO, temperature)
@test abs(nondimensional_relative_helmholtz_free_energy_0) <= ZERO * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::alternative::legendre::test::zero::nondimensional_relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_per_link_0 =
model.nondimensional_relative_helmholtz_free_energy_per_link(ZERO, temperature)
@test abs(nondimensional_relative_helmholtz_free_energy_per_link_0) <= ZERO
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 15991 | """
The extensible freely-jointed chain (EFJC) model thermodynamics in the isotensional ensemble approximated using an asymptotic approach and a Legendre transformation.
"""
module Legendre
using DocStringExtensions
using ........Polymers: PROJECT_ROOT
import .......Physics: BOLTZMANN_CONSTANT
"""
The structure of the thermodynamics of the EFJC model in the isotensional ensemble approximated using an asymptotic approach and a Legendre transformation.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The Helmholtz free energy ``\\psi`` as a function of the applied force ``f`` and temperature ``T``.
"""
helmholtz_free_energy::Function
"""
The Helmholtz free energy per link ``\\psi/N_b`` as a function of the applied force ``f`` and temperature ``T``.
"""
helmholtz_free_energy_per_link::Function
"""
The relative helmholtz free energy ``\\Delta\\psi\\equiv\\psi(f,T)-\\psi(0,T)`` as a function of the applied force ``f`` and temperature ``T``.
"""
relative_helmholtz_free_energy::Function
"""
The relative helmholtz free energy per link ``\\Delta\\psi/N_b`` as a function of the applied force ``f`` and temperature ``T``.
"""
relative_helmholtz_free_energy_per_link::Function
"""
The nondimensional helmholtz free energy ``N_b\\vartheta=\\beta\\psi`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``.
"""
nondimensional_helmholtz_free_energy::Function
"""
The nondimensional helmholtz free energy per link ``\\vartheta\\equiv\\beta\\psi/N_b`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``.
"""
nondimensional_helmholtz_free_energy_per_link::Function
"""
The nondimensional relative helmholtz free energy ``N_b\\Delta\\vartheta=\\beta\\Delta\\psi`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_relative_helmholtz_free_energy::Function
"""
The nondimensional relative helmholtz free energy per link ``\\Delta\\vartheta\\equiv\\beta\\Delta\\psi/N_b`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_relative_helmholtz_free_energy_per_link::Function
end
"""
The Helmholtz free energy ``\\psi`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, hinge mass ``m``, and link stiffness ``k_0``.
```math
\\psi(f, T) \\sim \\varphi(f, T) + f \\xi(f, T) \\quad \\text{for } N_b\\gg 1.
```
$(TYPEDSIGNATURES)
"""
function helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_legendre_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
)
end
"""
The Helmholtz free energy per link ``\\psi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b``, hinge mass ``m``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function helmholtz_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, hinge_mass_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_legendre_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64, Float64),
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
)
end
"""
The relative Helmholtz free energy ``\\Delta\\psi\\equiv\\psi(f,T)-\\psi(0,T)`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, link_length_i, link_stiffness_i, force_i, temperature_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_legendre_relative_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The relative Helmholtz free energy per link ``\\Delta\\psi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b`` and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_helmholtz_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_legendre_relative_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64),
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The nondimensional Helmholtz free energy ``N_b\\vartheta=\\beta\\psi`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, hinge mass ``m``, and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_legendre_nondimensional_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_force,
temperature,
)
end
"""
The nondimensional Helmholtz free energy per link ``\\vartheta\\equiv\\beta\\psi/N_b`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``,
parameterized by the link length ``\\ell_b``, hinge mass ``m``, and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_helmholtz_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_legendre_nondimensional_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64, Float64),
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
),
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_force,
temperature,
)
end
"""
The nondimensional relative Helmholtz free energy ``N_b\\Delta\\vartheta=\\beta\\Delta\\psi`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the number of links ``N_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_helmholtz_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, nondimensional_link_stiffness_i, nondimensional_force_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_legendre_nondimensional_relative_helmholtz_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64),
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
number_of_links,
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
The nondimensional relative Helmholtz free energy per link ``\\Delta\\vartheta\\equiv\\beta\\Delta\\psi/N_b`` as a function of the applied nondimensional force ``\\eta``
parameterized by the nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_force_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_legendre_nondimensional_relative_helmholtz_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
Initializes and returns an instance of the thermodynamics of the EFJC model in the isotensional ensemble approximated using an asymptotic approach and a Legendre transformation.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
BOLTZMANN_CONSTANT::Float64 = 8.314462618
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
(force, temperature) -> helmholtz_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
),
(force, temperature) -> helmholtz_free_energy_per_link(
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
),
(force, temperature) -> relative_helmholtz_free_energy(
number_of_links,
link_length,
link_stiffness,
force,
temperature,
),
(force, temperature) -> relative_helmholtz_free_energy_per_link(
link_length,
link_stiffness,
force,
temperature,
),
(nondimensional_force, temperature) -> nondimensional_helmholtz_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
temperature,
),
(nondimensional_force, temperature) ->
nondimensional_helmholtz_free_energy_per_link(
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
temperature,
),
(nondimensional_force, temperature) ->
nondimensional_relative_helmholtz_free_energy(
number_of_links,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
(nondimensional_force, temperature) ->
nondimensional_relative_helmholtz_free_energy_per_link(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 30627 | module Test
using Test
using Polymers.Physics: BOLTZMANN_CONSTANT
using Polymers.Physics.SingleChain: ZERO, parameters
using Polymers.Physics.SingleChain.Efjc.Thermodynamics.Isotensional.Asymptotic.Legendre:
EFJC
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::nondimensional::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy =
model.nondimensional_helmholtz_free_energy(nondimensional_force, temperature)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
helmholtz_free_energy = model.helmholtz_free_energy(force, temperature)
residual_abs =
helmholtz_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_helmholtz_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::nondimensional::helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(force, temperature)
residual_abs =
helmholtz_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::nondimensional::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(force, temperature)
residual_abs =
relative_helmholtz_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::nondimensional::relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(force, temperature)
residual_abs =
relative_helmholtz_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::per_link::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
helmholtz_free_energy = model.helmholtz_free_energy(force, temperature)
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(force, temperature)
residual_abs =
helmholtz_free_energy / number_of_links - helmholtz_free_energy_per_link
residual_rel = residual_abs / helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::per_link::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(force, temperature)
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(force, temperature)
residual_abs =
relative_helmholtz_free_energy / number_of_links -
relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::per_link::nondimensional_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy =
model.nondimensional_helmholtz_free_energy(nondimensional_force, temperature)
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy / number_of_links -
nondimensional_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::per_link::nondimensional_relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_force,
temperature,
)
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_relative_helmholtz_free_energy / number_of_links -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_helmholtz_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::relative::helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
helmholtz_free_energy = model.helmholtz_free_energy(force, temperature)
helmholtz_free_energy_0 = model.helmholtz_free_energy(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_helmholtz_free_energy =
model.relative_helmholtz_free_energy(force, temperature)
residual_abs =
helmholtz_free_energy - helmholtz_free_energy_0 - relative_helmholtz_free_energy
residual_rel = residual_abs / helmholtz_free_energy_0
@test abs(residual_abs) <=
BOLTZMANN_CONSTANT * temperature * number_of_links * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::relative::helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
helmholtz_free_energy_per_link =
model.helmholtz_free_energy_per_link(force, temperature)
helmholtz_free_energy_per_link_0 = model.helmholtz_free_energy_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_helmholtz_free_energy_per_link =
model.relative_helmholtz_free_energy_per_link(force, temperature)
residual_abs =
helmholtz_free_energy_per_link - helmholtz_free_energy_per_link_0 -
relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / helmholtz_free_energy_per_link_0
@test abs(residual_abs) <= BOLTZMANN_CONSTANT * temperature * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::relative::nondimensional_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy =
model.nondimensional_helmholtz_free_energy(nondimensional_force, temperature)
nondimensional_helmholtz_free_energy_0 =
model.nondimensional_helmholtz_free_energy(ZERO, temperature)
nondimensional_relative_helmholtz_free_energy =
model.nondimensional_relative_helmholtz_free_energy(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy - nondimensional_helmholtz_free_energy_0 -
nondimensional_relative_helmholtz_free_energy
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_0
@test abs(residual_abs) <= number_of_links * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::relative::nondimensional_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_helmholtz_free_energy_per_link =
model.nondimensional_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_helmholtz_free_energy_per_link_0 =
model.nondimensional_helmholtz_free_energy_per_link(ZERO, temperature)
nondimensional_relative_helmholtz_free_energy_per_link =
model.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_helmholtz_free_energy_per_link -
nondimensional_helmholtz_free_energy_per_link_0 -
nondimensional_relative_helmholtz_free_energy_per_link
residual_rel = residual_abs / nondimensional_helmholtz_free_energy_per_link_0
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::zero::relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_helmholtz_free_energy_0 = model.relative_helmholtz_free_energy(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
@test abs(relative_helmholtz_free_energy_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::zero::relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_helmholtz_free_energy_per_link_0 =
model.relative_helmholtz_free_energy_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
@test abs(relative_helmholtz_free_energy_per_link_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::zero::nondimensional_relative_helmholtz_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_0 =
model.nondimensional_relative_helmholtz_free_energy(ZERO, temperature)
@test abs(nondimensional_relative_helmholtz_free_energy_0) <= ZERO * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::legendre::test::zero::nondimensional_relative_helmholtz_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_helmholtz_free_energy_per_link_0 =
model.nondimensional_relative_helmholtz_free_energy_per_link(ZERO, temperature)
@test abs(nondimensional_relative_helmholtz_free_energy_per_link_0) <= ZERO
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 22676 | """
The extensible freely-jointed chain (EFJC) model thermodynamics in the isotensional ensemble approximated using an reduced asymptotic approach.
"""
module Reduced
using DocStringExtensions
using ........Polymers: PROJECT_ROOT
import .......Physics: BOLTZMANN_CONSTANT
include("legendre/mod.jl")
"""
The structure of the thermodynamics of the EFJC model in the isotensional ensemble approximated using an reduced asymptotic approach.
$(FIELDS)
"""
struct EFJC
"""
The number of links in the chain ``N_b``.
"""
number_of_links::UInt8
"""
The length of each link in the chain ``\\ell_b`` in units of nm.
"""
link_length::Float64
"""
The mass of each hinge in the chain ``m`` in units of kg/mol.
"""
hinge_mass::Float64
"""
The stiffness of each link in the chain ``k_0`` in units of J/(mol⋅nm^2).
"""
link_stiffness::Float64
"""
The thermodynamic functions of the model in the isotensional ensemble approximated using an reduced asymptotic approach.
"""
legendre::Any
"""
The expected end-to-end length ``\\xi`` as a function of the applied force ``f`` and temperature ``T``.
"""
end_to_end_length::Function
"""
The expected end-to-end length per link ``\\xi/N_b=\\ell_b\\gamma`` as a function of the applied force ``f`` and temperature ``T``.
"""
end_to_end_length_per_link::Function
"""
The expected nondimensional end-to-end length ``N_b\\gamma=\\xi/\\ell_b`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_end_to_end_length::Function
"""
The expected nondimensional end-to-end length per link ``\\gamma\\equiv\\xi/N_b\\ell_b`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_end_to_end_length_per_link::Function
"""
The Gibbs free energy ``\\varphi`` as a function of the applied force ``f`` and temperature ``T``.
"""
gibbs_free_energy::Function
"""
The Gibbs free energy per link ``\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``.
"""
gibbs_free_energy_per_link::Function
"""
The relative Gibbs free energy ``\\Delta\\varphi\\equiv\\varphi(f,T)-\\varphi(0,T)`` as a function of the applied force ``f`` and temperature ``T``.
"""
relative_gibbs_free_energy::Function
"""
The relative Gibbs free energy per link ``\\Delta\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``.
"""
relative_gibbs_free_energy_per_link::Function
"""
The nondimensional Gibbs free energy ``N_b\\varrho=\\beta\\varphi`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``.
"""
nondimensional_gibbs_free_energy::Function
"""
The nondimensional Gibbs free energy per link ``\\varrho\\equiv\\beta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``.
"""
nondimensional_gibbs_free_energy_per_link::Function
"""
The nondimensional relative Gibbs free energy ``N_b\\Delta\\varrho=\\beta\\Delta\\varphi`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_relative_gibbs_free_energy::Function
"""
The nondimensional relative Gibbs free energy per link ``\\Delta\\varrho\\equiv\\beta\\Delta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta``.
"""
nondimensional_relative_gibbs_free_energy_per_link::Function
end
"""
The expected end-to-end length ``N_b\\gamma=\\xi/\\ell_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``,
```math
\\xi(f, T) = -\\frac{\\partial\\varphi}{\\partial f}.
```
$(TYPEDSIGNATURES)
"""
function end_to_end_length(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, link_length_i, link_stiffness_i, force_i, temperature_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_reduced_end_to_end_length,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The expected end-to-end length per link ``\\xi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b`` and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function end_to_end_length_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_reduced_end_to_end_length_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64),
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The expected nondimensional end-to-end length ``N_b\\gamma=\\xi/\\ell_b`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the number of links ``N_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_end_to_end_length(
number_of_links::Union{UInt8,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, nondimensional_link_stiffness_i, nondimensional_force_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_reduced_nondimensional_end_to_end_length,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64),
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
number_of_links,
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
The expected nondimensional end-to-end length per link ``\\gamma\\equiv \\xi/N_b\\ell_b`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``,
given by [Buche et al.](https://doi.org/10.1103/PhysRevE.106.024502) as
```math
\\gamma(\\eta) \\sim \\mathcal{L}(\\eta) + \\frac{\\eta}{\\kappa} \\quad \\text{for } \\kappa\\gg 1,
```
where ``\\mathcal{L}(x)=\\coth(x)-1/x`` is the Langevin function.
$(TYPEDSIGNATURES)
"""
function nondimensional_end_to_end_length_per_link(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_force_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_reduced_nondimensional_end_to_end_length_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
The Gibbs free energy ``\\varphi`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, hinge mass ``m``, and link stiffness ``k_0``.
```math
\\varphi(f, T) = -kT\\ln Z(f, T).
```
$(TYPEDSIGNATURES)
"""
function gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_reduced_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
)
end
"""
The Gibbs free energy per link ``\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b``, hinge mass ``m``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function gibbs_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, hinge_mass_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_reduced_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64, Float64),
link_length_i,
hinge_mass_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
)
end
"""
The relative Gibbs free energy ``\\Delta\\varphi\\equiv\\varphi(f,T)-\\varphi(0,T)`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, link_length_i, link_stiffness_i, force_i, temperature_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_reduced_relative_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
number_of_links,
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The relative Gibbs free energy per link ``\\Delta\\varphi/N_b`` as a function of the applied force ``f`` and temperature ``T``,
parameterized by the link length ``\\ell_b`` and link stiffness ``k_0``.
$(TYPEDSIGNATURES)
"""
function relative_gibbs_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
link_stiffness::Union{Float64,Vector,Matrix,Array},
force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(link_length_i, link_stiffness_i, force_i, temperature_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_reduced_relative_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64),
link_length_i,
link_stiffness_i,
force_i,
temperature_i,
),
link_length,
link_stiffness,
force,
temperature,
)
end
"""
The nondimensional Gibbs free energy ``N_b\\varrho=\\beta\\varphi`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``,
parameterized by the number of links ``N_b``, link length ``\\ell_b``, hinge mass ``m``, and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_reduced_nondimensional_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64, Float64, Float64, Float64),
number_of_links_i,
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
),
number_of_links,
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_force,
temperature,
)
end
"""
The nondimensional Gibbs free energy per link ``\\varrho\\equiv\\beta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta`` and temperature ``T``,
parameterized by the link length ``\\ell_b``, hinge mass ``m``, and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_gibbs_free_energy_per_link(
link_length::Union{Float64,Vector,Matrix,Array},
hinge_mass::Union{Float64,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
temperature::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_reduced_nondimensional_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64, Float64, Float64, Float64),
link_length_i,
hinge_mass_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
temperature_i,
),
link_length,
hinge_mass,
nondimensional_link_stiffness,
nondimensional_force,
temperature,
)
end
"""
The nondimensional relative Gibbs free energy ``N_b\\Delta\\varrho=\\beta\\Delta\\varphi`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the number of links ``N_b`` and nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``.
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_gibbs_free_energy(
number_of_links::Union{UInt8,Vector,Matrix,Array},
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(number_of_links_i, nondimensional_link_stiffness_i, nondimensional_force_i) ->
ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_reduced_nondimensional_relative_gibbs_free_energy,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(UInt8, Float64, Float64),
number_of_links_i,
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
number_of_links,
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
The nondimensional relative Gibbs free energy per link ``\\Delta\\varrho\\equiv\\beta\\Delta\\varphi/N_b`` as a function of the applied nondimensional force ``\\eta``,
parameterized by the nondimensional link stiffness ``\\kappa\\equiv\\beta k_0\\ell_b^2``,
given by [Buche et al.](https://doi.org/10.1103/PhysRevE.106.024502) as
```math
\\Delta\\varrho(\\eta) = \\ln\\left[\\frac{\\eta}{\\sinh(\\eta)}\\right] - \\frac{\\eta^2}{2\\kappa} \\quad \\text{for } \\kappa\\gg 1.
```
$(TYPEDSIGNATURES)
"""
function nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_link_stiffness::Union{Float64,Vector,Matrix,Array},
nondimensional_force::Union{Float64,Vector,Matrix,Array},
)::Union{Float64,Vector,Matrix,Array}
return broadcast(
(nondimensional_link_stiffness_i, nondimensional_force_i) -> ccall(
(
:physics_single_chain_efjc_thermodynamics_isotensional_asymptotic_reduced_nondimensional_relative_gibbs_free_energy_per_link,
string(PROJECT_ROOT, "target/release/libpolymers"),
),
Float64,
(Float64, Float64),
nondimensional_link_stiffness_i,
nondimensional_force_i,
),
nondimensional_link_stiffness,
nondimensional_force,
)
end
"""
Initializes and returns an instance of the thermodynamics of the EFJC model in the isotensional ensemble approximated using an reduced asymptotic approach.
$(TYPEDSIGNATURES)
"""
function EFJC(
number_of_links::UInt8,
link_length::Float64,
hinge_mass::Float64,
link_stiffness::Float64,
)
BOLTZMANN_CONSTANT::Float64 = 8.314462618
return EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
Legendre.EFJC(number_of_links, link_length, hinge_mass, link_stiffness),
(force, temperature) -> end_to_end_length(
number_of_links,
link_length,
link_stiffness,
force,
temperature,
),
(force, temperature) ->
end_to_end_length_per_link(link_length, link_stiffness, force, temperature),
(nondimensional_force, temperature) -> nondimensional_end_to_end_length(
number_of_links,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
(nondimensional_force, temperature) -> nondimensional_end_to_end_length_per_link(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
(force, temperature) -> gibbs_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
),
(force, temperature) -> gibbs_free_energy_per_link(
link_length,
hinge_mass,
link_stiffness,
force,
temperature,
),
(force, temperature) -> relative_gibbs_free_energy(
number_of_links,
link_length,
link_stiffness,
force,
temperature,
),
(force, temperature) -> relative_gibbs_free_energy_per_link(
link_length,
link_stiffness,
force,
temperature,
),
(nondimensional_force, temperature) -> nondimensional_gibbs_free_energy(
number_of_links,
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
temperature,
),
(nondimensional_force, temperature) -> nondimensional_gibbs_free_energy_per_link(
link_length,
hinge_mass,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
temperature,
),
(nondimensional_force, temperature) -> nondimensional_relative_gibbs_free_energy(
number_of_links,
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
(nondimensional_force, temperature) ->
nondimensional_relative_gibbs_free_energy_per_link(
link_stiffness * link_length^2 / BOLTZMANN_CONSTANT / temperature,
nondimensional_force,
),
)
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
|
[
"BSD-3-Clause"
] | 0.3.7 | 5c9185bac8d9a5f2d96a37387c88fa5cf535e1be | code | 63826 | module Test
using Test
using Polymers.Physics: BOLTZMANN_CONSTANT
using Polymers.Physics.SingleChain: ZERO, parameters
using Polymers.Physics.SingleChain.Efjc.Thermodynamics.Isotensional.Asymptotic.Reduced: EFJC
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::base::init" begin
@test isa(
EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
),
Any,
)
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::base::number_of_links" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
@test EFJC(
number_of_links,
parameters.link_length_reference,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).number_of_links == number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::base::link_length" begin
for _ = 1:parameters.number_of_loops
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
link_length,
parameters.hinge_mass_reference,
parameters.link_stiffness_reference,
).link_length == link_length
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::base::hinge_mass" begin
for _ = 1:parameters.number_of_loops
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
hinge_mass,
parameters.link_stiffness_reference,
).hinge_mass == hinge_mass
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::base::link_stiffness" begin
for _ = 1:parameters.number_of_loops
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test EFJC(
parameters.number_of_links_minimum,
parameters.link_length_reference,
parameters.hinge_mass_reference,
link_stiffness,
).link_stiffness == link_stiffness
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::base::all_parameters" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
@test all(
EFJC(
number_of_links,
link_length,
hinge_mass,
link_stiffness,
).number_of_links == number_of_links &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_length ==
link_length &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).hinge_mass ==
hinge_mass &&
EFJC(number_of_links, link_length, hinge_mass, link_stiffness).link_stiffness ==
link_stiffness,
)
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::nondimensional::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
residual_abs = end_to_end_length / link_length - nondimensional_end_to_end_length
residual_rel = residual_abs / nondimensional_end_to_end_length
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::nondimensional::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
residual_abs =
end_to_end_length_per_link / link_length -
nondimensional_end_to_end_length_per_link
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::nondimensional::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
residual_abs =
gibbs_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_gibbs_free_energy
residual_rel = residual_abs / nondimensional_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::nondimensional::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
residual_abs =
gibbs_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::nondimensional::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
residual_abs =
relative_gibbs_free_energy / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_gibbs_free_energy
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::nondimensional::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
residual_abs =
relative_gibbs_free_energy_per_link / BOLTZMANN_CONSTANT / temperature -
nondimensional_relative_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::per_link::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
residual_abs = end_to_end_length / number_of_links - end_to_end_length_per_link
residual_rel = residual_abs / end_to_end_length_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::per_link::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_end_to_end_length / number_of_links -
nondimensional_end_to_end_length_per_link
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::per_link::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
residual_abs = gibbs_free_energy / number_of_links - gibbs_free_energy_per_link
residual_rel = residual_abs / gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::per_link::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
residual_abs =
relative_gibbs_free_energy / number_of_links -
relative_gibbs_free_energy_per_link
residual_rel = residual_abs / relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::per_link::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_gibbs_free_energy / number_of_links -
nondimensional_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::per_link::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_relative_gibbs_free_energy / number_of_links -
nondimensional_relative_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::relative::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
gibbs_free_energy_0 = model.gibbs_free_energy(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
residual_abs = gibbs_free_energy - gibbs_free_energy_0 - relative_gibbs_free_energy
residual_rel = residual_abs / gibbs_free_energy_0
@test abs(residual_abs) <=
BOLTZMANN_CONSTANT * temperature * number_of_links * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::relative::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
gibbs_free_energy_per_link_0 = model.gibbs_free_energy_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
residual_abs =
gibbs_free_energy_per_link - gibbs_free_energy_per_link_0 -
relative_gibbs_free_energy_per_link
residual_rel = residual_abs / gibbs_free_energy_per_link_0
@test abs(residual_abs) <= BOLTZMANN_CONSTANT * temperature * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::relative::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
nondimensional_gibbs_free_energy_0 =
model.nondimensional_gibbs_free_energy(ZERO, temperature)
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_gibbs_free_energy - nondimensional_gibbs_free_energy_0 -
nondimensional_relative_gibbs_free_energy
residual_rel = residual_abs / nondimensional_gibbs_free_energy_0
@test abs(residual_abs) <= number_of_links * parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::relative::nondimensional_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_gibbs_free_energy_per_link_0 =
model.nondimensional_gibbs_free_energy_per_link(ZERO, temperature)
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
residual_abs =
nondimensional_gibbs_free_energy_per_link -
nondimensional_gibbs_free_energy_per_link_0 -
nondimensional_relative_gibbs_free_energy_per_link
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link_0
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::zero::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_gibbs_free_energy_0 = model.relative_gibbs_free_energy(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
@test abs(relative_gibbs_free_energy_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::zero::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
relative_gibbs_free_energy_per_link_0 = model.relative_gibbs_free_energy_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
@test abs(relative_gibbs_free_energy_per_link_0) <=
ZERO * BOLTZMANN_CONSTANT * temperature
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::zero::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy_0 =
model.nondimensional_relative_gibbs_free_energy(ZERO, temperature)
@test abs(nondimensional_relative_gibbs_free_energy_0) <= ZERO * number_of_links
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::zero::nondimensional_relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_relative_gibbs_free_energy_per_link_0 =
model.nondimensional_relative_gibbs_free_energy_per_link(ZERO, temperature)
@test abs(nondimensional_relative_gibbs_free_energy_per_link_0) <= ZERO
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::connection::end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
h = parameters.rel_tol * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_from_derivative =
-(
model.relative_gibbs_free_energy(force + 0.5 * h, temperature) -
model.relative_gibbs_free_energy(force - 0.5 * h, temperature)
) / h
residual_abs = end_to_end_length - end_to_end_length_from_derivative
residual_rel = residual_abs / end_to_end_length
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::connection::end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
h = parameters.rel_tol * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link_from_derivative =
-(
model.relative_gibbs_free_energy_per_link(force + 0.5 * h, temperature) -
model.relative_gibbs_free_energy_per_link(force - 0.5 * h, temperature)
) / h
residual_abs =
end_to_end_length_per_link - end_to_end_length_per_link_from_derivative
residual_rel = residual_abs / end_to_end_length_per_link
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::connection::nondimensional_end_to_end_length" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
h = parameters.rel_tol
nondimensional_end_to_end_length_from_derivative =
-(
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force + 0.5 * h,
temperature,
) - model.nondimensional_relative_gibbs_free_energy(
nondimensional_force - 0.5 * h,
temperature,
)
) / h
residual_abs =
nondimensional_end_to_end_length -
nondimensional_end_to_end_length_from_derivative
residual_rel = residual_abs / nondimensional_end_to_end_length
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::connection::nondimensional_end_to_end_length_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
h = parameters.rel_tol
nondimensional_end_to_end_length_per_link_from_derivative =
-(
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force + 0.5 * h,
temperature,
) - model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force - 0.5 * h,
temperature,
)
) / h
residual_abs =
nondimensional_end_to_end_length_per_link -
nondimensional_end_to_end_length_per_link_from_derivative
residual_rel = residual_abs / nondimensional_end_to_end_length_per_link
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::legendre::gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
gibbs_free_energy = model.gibbs_free_energy(force, temperature)
gibbs_free_energy_legendre =
model.legendre.helmholtz_free_energy(force, temperature) -
force * end_to_end_length
residual_abs = gibbs_free_energy - gibbs_free_energy_legendre
residual_rel = residual_abs / gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::legendre::gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
gibbs_free_energy_per_link = model.gibbs_free_energy_per_link(force, temperature)
gibbs_free_energy_per_link_legendre =
model.legendre.helmholtz_free_energy_per_link(force, temperature) -
force * end_to_end_length_per_link
residual_abs = gibbs_free_energy_per_link - gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::legendre::relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length = model.end_to_end_length(force, temperature)
end_to_end_length_0 = model.end_to_end_length(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy = model.relative_gibbs_free_energy(force, temperature)
relative_gibbs_free_energy_legendre =
model.legendre.relative_helmholtz_free_energy(force, temperature) -
force * end_to_end_length +
ZERO * BOLTZMANN_CONSTANT * temperature / link_length * end_to_end_length_0
residual_abs = relative_gibbs_free_energy - relative_gibbs_free_energy_legendre
residual_rel = residual_abs / relative_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::legendre::relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
end_to_end_length_per_link = model.end_to_end_length_per_link(force, temperature)
end_to_end_length_per_link_0 = model.end_to_end_length_per_link(
ZERO * BOLTZMANN_CONSTANT * temperature / link_length,
temperature,
)
relative_gibbs_free_energy_per_link =
model.relative_gibbs_free_energy_per_link(force, temperature)
relative_gibbs_free_energy_per_link_legendre =
model.legendre.relative_helmholtz_free_energy_per_link(force, temperature) -
force * end_to_end_length_per_link +
ZERO * BOLTZMANN_CONSTANT * temperature / link_length *
end_to_end_length_per_link_0
residual_abs =
relative_gibbs_free_energy_per_link -
relative_gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::legendre::nondimensional_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
nondimensional_gibbs_free_energy =
model.nondimensional_gibbs_free_energy(nondimensional_force, temperature)
nondimensional_gibbs_free_energy_legendre =
model.legendre.nondimensional_helmholtz_free_energy(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length
residual_abs =
nondimensional_gibbs_free_energy - nondimensional_gibbs_free_energy_legendre
residual_rel = residual_abs / nondimensional_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::legendre::nondimensional_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_gibbs_free_energy_per_link =
model.nondimensional_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_gibbs_free_energy_per_link_legendre =
model.legendre.nondimensional_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length_per_link
residual_abs =
nondimensional_gibbs_free_energy_per_link -
nondimensional_gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / nondimensional_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::legendre::nondimensional_relative_gibbs_free_energy" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length =
model.nondimensional_end_to_end_length(nondimensional_force, temperature)
nondimensional_end_to_end_length_0 =
model.nondimensional_end_to_end_length(ZERO, temperature)
nondimensional_relative_gibbs_free_energy =
model.nondimensional_relative_gibbs_free_energy(
nondimensional_force,
temperature,
)
nondimensional_relative_gibbs_free_energy_legendre =
model.legendre.nondimensional_relative_helmholtz_free_energy(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length +
ZERO * nondimensional_end_to_end_length_0
residual_abs =
nondimensional_relative_gibbs_free_energy -
nondimensional_relative_gibbs_free_energy_legendre
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::legendre::nondimensional_relative_gibbs_free_energy_per_link" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
nondimensional_end_to_end_length_per_link =
model.nondimensional_end_to_end_length_per_link(
nondimensional_force,
temperature,
)
nondimensional_end_to_end_length_per_link_0 =
model.nondimensional_end_to_end_length_per_link(ZERO, temperature)
nondimensional_relative_gibbs_free_energy_per_link =
model.nondimensional_relative_gibbs_free_energy_per_link(
nondimensional_force,
temperature,
)
nondimensional_relative_gibbs_free_energy_per_link_legendre =
model.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force,
temperature,
) - nondimensional_force * nondimensional_end_to_end_length_per_link +
ZERO * nondimensional_end_to_end_length_per_link_0
residual_abs =
nondimensional_relative_gibbs_free_energy_per_link -
nondimensional_relative_gibbs_free_energy_per_link_legendre
residual_rel = residual_abs / nondimensional_relative_gibbs_free_energy_per_link
@test abs(residual_abs) <= parameters.abs_tol &&
abs(residual_rel) <= parameters.rel_tol
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::legendre_connection::force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
force = nondimensional_force * BOLTZMANN_CONSTANT * temperature / link_length
h = parameters.rel_tol * BOLTZMANN_CONSTANT * temperature / link_length
force_from_derivative =
(
model.legendre.relative_helmholtz_free_energy(
force + 0.5 * h,
temperature,
) -
model.legendre.relative_helmholtz_free_energy(force - 0.5 * h, temperature)
) / (
model.end_to_end_length(force + 0.5 * h, temperature) -
model.end_to_end_length(force - 0.5 * h, temperature)
)
residual_abs = force - force_from_derivative
residual_rel = residual_abs / force
@test abs(residual_rel) <= h
end
end
@testset "physics::single_chain::efjc::thermodynamics::isotensional::asymptotic::reduced::test::legendre_connection::nondimensional_force" begin
for _ = 1:parameters.number_of_loops
number_of_links =
rand(parameters.number_of_links_minimum:parameters.number_of_links_maximum)
link_length =
parameters.link_length_reference + parameters.link_length_scale * (0.5 - rand())
hinge_mass =
parameters.hinge_mass_reference + parameters.hinge_mass_scale * (0.5 - rand())
link_stiffness =
parameters.link_stiffness_reference +
parameters.link_stiffness_scale * (0.5 - rand())
model = EFJC(number_of_links, link_length, hinge_mass, link_stiffness)
nondimensional_force =
parameters.nondimensional_force_reference +
parameters.nondimensional_force_scale * (0.5 - rand())
temperature =
parameters.temperature_reference + parameters.temperature_scale * (0.5 - rand())
h = parameters.rel_tol
nondimensional_force_from_derivative =
(
model.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force + 0.5 * h,
temperature,
) - model.legendre.nondimensional_relative_helmholtz_free_energy_per_link(
nondimensional_force - 0.5 * h,
temperature,
)
) / (
model.nondimensional_end_to_end_length_per_link(
nondimensional_force + 0.5 * h,
temperature,
) - model.nondimensional_end_to_end_length_per_link(
nondimensional_force - 0.5 * h,
temperature,
)
)
residual_abs = nondimensional_force - nondimensional_force_from_derivative
residual_rel = residual_abs / nondimensional_force
@test abs(residual_rel) <= h
end
end
end
| Polymers | https://github.com/sandialabs/Polymers.git |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.