Commit bf947d1b authored by Martin Reinecke's avatar Martin Reinecke

Merge branch 'cf_wo_asperity' into 'NIFTy_7'

Allow for opting out of asperity and flexibility

See merge request !556
parents 2e872c5d 9dc11964
Pipeline #77882 passed with stages
in 26 minutes and 6 seconds
Changes since NIFTy 6
=====================
CorrelatedFieldMaker interface change
-------------------------------------
The interface of `ift.CorrelatedFieldMaker.make` and
`ift.CorrelatedFieldMaker.add_fluctuations` changed; it now expects the mean
and the standard deviation of their various parameters not as separate
arguments but as a tuple.
Furthermore, it is now possible to disable the asperity and the flexibility
together with the asperity in the correlated field model. Note that disabling
only the flexibility is not possible.
SimpleCorrelatedField
---------------------
A simplified version of the correlated field model was introduced which does not
allow for multiple power spectra, the presence of a degree of freedom parameter
`dofdex`, or `total_N` larger than zero. Except for the above mentioned
limitations, it is equivalent to `ift.CorrelatedFieldMaker`. Hence, if one
wants to understand the implementation idea behind the model, it is easier to
grasp from reading `ift.SimpleCorrelatedField` than from going through
`ift.CorrelatedFieldMaker`.
Change in external dependencies
-------------------------------
......@@ -20,7 +43,7 @@ The implementation tests for nonlinear operators are now available in
MetricGaussianKL interface
--------------------------
Users do not instanciate `MetricGaussianKL` by its constructor anymore. Rather
Users do not instantiate `MetricGaussianKL` by its constructor anymore. Rather
`MetricGaussianKL.make()` shall be used.
......@@ -91,10 +114,10 @@ New approach for sampling complex numbers
When calling draw_sample_with_dtype with a complex dtype,
the variance is now used for the imaginary part and real part separately.
This is done in order to be consistent with the Hamiltonian.
Note that by this,
Note that by this,
```
np.std(ift.from_random(domain, 'normal', dtype=np.complex128).val)
````
````
does not give 1, but sqrt(2) as a result.
......
......@@ -135,7 +135,7 @@
"## Before the Action: The Moment-Matched Log-Normal Distribution\n",
"Many properties of the correlated field are modelled as being lognormally distributed.\n",
"\n",
"The distribution models are parametrized via their means `_mean` and standard-deviations `_stddev`.\n",
"The distribution models are parametrized via their means and standard-deviations (first and second position in tuple).\n",
"\n",
"To get a feeling of how the ratio of the `mean` and `stddev` parameters influences the distribution shape,\n",
"here are a few example histograms: (observe the x-axis!)"
......@@ -189,21 +189,16 @@
"# Neutral model parameters yielding a quasi-constant field\n",
"cf_make_pars = {\n",
" 'offset_mean': 0.,\n",
" 'offset_std_mean': 1e-3,\n",
" 'offset_std_std': 1e-16,\n",
" 'offset_std': (1e-3, 1e-16),\n",
" 'prefix': ''\n",
"}\n",
"\n",
"cf_x_fluct_pars = {\n",
" 'target_subdomain': x_space,\n",
" 'fluctuations_mean': 1e-3,\n",
" 'fluctuations_stddev': 1e-16,\n",
" 'flexibility_mean': 1e-3,\n",
" 'flexibility_stddev': 1e-16,\n",
" 'asperity_mean': 1e-3,\n",
" 'asperity_stddev': 1e-16,\n",
" 'loglogavgslope_mean': 0.,\n",
" 'loglogavgslope_stddev': 1e-16\n",
" 'fluctuations': (1e-3, 1e-16),\n",
" 'flexibility': (1e-3, 1e-16),\n",
" 'asperity': (1e-3, 1e-16),\n",
" 'loglogavgslope': (0., 1e-16)\n",
"}\n",
"\n",
"init_model(cf_make_pars, cf_x_fluct_pars)"
......@@ -225,18 +220,18 @@
"source": [
"# Parameter Showcases\n",
"\n",
"## The `fluctuations_` parameters of `add_fluctuations()`\n",
"## The `fluctuations` parameters of `add_fluctuations()`\n",
"\n",
"determine the **amplitude of variations along the field dimension**\n",
"for which `add_fluctuations` is called.\n",
"\n",
"`fluctuations_mean` set the _average_ amplitude of the fields fluctuations along the given dimension,\\\n",
"`fluctuations_stddev` sets the width and shape of the amplitude distribution.\n",
"`fluctuations[0]` set the _average_ amplitude of the fields fluctuations along the given dimension,\\\n",
"`fluctuations[1]` sets the width and shape of the amplitude distribution.\n",
"\n",
"The amplitude is modelled as being log-normally distributed,\n",
"see `The Moment-Matched Log-Normal Distribution` above for details.\n",
"\n",
"#### `fluctuations_mean`:"
"#### `fluctuations` mean:"
]
},
{
......@@ -245,14 +240,14 @@
"metadata": {},
"outputs": [],
"source": [
"vary_parameter('fluctuations_mean', [0.05, 0.5, 2.], samples_vary_in='xi')"
"vary_parameter('fluctuations', [(0.05, 1e-16), (0.5, 1e-16), (2., 1e-16)], samples_vary_in='xi')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### `fluctuations_stddev`:"
"#### `fluctuations` std:"
]
},
{
......@@ -261,21 +256,21 @@
"metadata": {},
"outputs": [],
"source": [
"cf_x_fluct_pars['fluctuations_mean'] = 1.0\n",
"vary_parameter('fluctuations_stddev', [0.01, 0.1, 1.0], samples_vary_in='fluctuations')"
"vary_parameter('fluctuations', [(1., 0.01), (1., 0.1), (1., 1.)], samples_vary_in='fluctuations')\n",
"cf_x_fluct_pars['fluctuations'] = (1., 1e-16)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## The `loglogavgslope_` parameters of `add_fluctuations()`\n",
"## The `loglogavgslope` parameters of `add_fluctuations()`\n",
"\n",
"determine **the slope of the loglog-linear (power law) component of the power spectrum**.\n",
"\n",
"The slope is modelled to be normally distributed.\n",
"\n",
"#### `loglogavgslope_mean`:"
"#### `loglogavgslope` mean:"
]
},
{
......@@ -284,14 +279,14 @@
"metadata": {},
"outputs": [],
"source": [
"vary_parameter('loglogavgslope_mean', [-3., -1., 1.], samples_vary_in='xi')"
"vary_parameter('loglogavgslope', [(-3., 1e-16), (-1., 1e-16), (1., 1e-16)], samples_vary_in='xi')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### `loglogavgslope_stddev`:"
"#### `loglogavgslope` std:"
]
},
{
......@@ -300,25 +295,25 @@
"metadata": {},
"outputs": [],
"source": [
"cf_x_fluct_pars['loglogavgslope_mean'] = -1.0\n",
"vary_parameter('loglogavgslope_stddev', [0.01, 0.1, 1.0], samples_vary_in='loglogavgslope')"
"vary_parameter('loglogavgslope', [(-1., 0.01), (-1., 0.1), (-1., 1.0)], samples_vary_in='loglogavgslope')\n",
"cf_x_fluct_pars['loglogavgslope'] = (-1., 1e-16)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## The `flexibility_` parameters of `add_fluctuations()`\n",
"## The `flexibility` parameters of `add_fluctuations()`\n",
"\n",
"determine **the amplitude of the integrated Wiener process component of the power spectrum**\n",
"(how strong the power spectrum varies besides the power-law).\n",
"\n",
"`flexibility_mean` sets the _average_ amplitude of the i.g.p. component,\n",
"`flexibility_stddev` sets how much the amplitude can vary.\\\n",
"`flexibility[0]` sets the _average_ amplitude of the i.g.p. component,\\\n",
"`flexibility[1]` sets how much the amplitude can vary.\\\n",
"These two parameters feed into a moment-matched log-normal distribution model,\n",
"see above for a demo of its behavior.\n",
"\n",
"#### `flexibility_mean`:"
"#### `flexibility` mean:"
]
},
{
......@@ -327,14 +322,14 @@
"metadata": {},
"outputs": [],
"source": [
"vary_parameter('flexibility_mean', [0.1, 1.0, 3.0], samples_vary_in='spectrum')"
"vary_parameter('flexibility', [(0.1, 1e-16), (1.0, 1e-16), (3.0, 1e-16)], samples_vary_in='spectrum')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### `flexibility_stddev`:"
"#### `flexibility` std:"
]
},
{
......@@ -343,23 +338,23 @@
"metadata": {},
"outputs": [],
"source": [
"cf_x_fluct_pars['flexibility_mean'] = 2.0\n",
"vary_parameter('flexibility_stddev', [0.01, 0.1, 1.0], samples_vary_in='flexibility')"
"vary_parameter('flexibility', [(2., 0.01), (2., 0.1), (2., 1.)], samples_vary_in='flexibility')\n",
"cf_x_fluct_pars['flexibility'] = (2., 1e-16)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## The `asperity_` parameters of `add_fluctuations()`\n",
"## The `asperity` parameters of `add_fluctuations()`\n",
"\n",
"`asperity_` determines **how rough the integrated Wiener process component of the power spectrum is**.\n",
"`asperity` determines **how rough the integrated Wiener process component of the power spectrum is**.\n",
"\n",
"`asperity_mean` sets the average roughness, `asperity_stddev` sets how much the roughness can vary.\\\n",
"`asperity[0]` sets the average roughness, `asperity[1]` sets how much the roughness can vary.\\\n",
"These two parameters feed into a moment-matched log-normal distribution model,\n",
"see above for a demo of its behavior.\n",
"\n",
"#### `asperity_mean`:"
"#### `asperity` mean:"
]
},
{
......@@ -368,14 +363,14 @@
"metadata": {},
"outputs": [],
"source": [
"vary_parameter('asperity_mean', [0.001, 1.0, 5.0], samples_vary_in='spectrum')"
"vary_parameter('asperity', [(0.001, 1e-16), (1.0, 1e-16), (5., 1e-16)], samples_vary_in='spectrum')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### `asperity_stddev`:"
"#### `asperity` std:"
]
},
{
......@@ -384,8 +379,8 @@
"metadata": {},
"outputs": [],
"source": [
"cf_x_fluct_pars['asperity_mean'] = 1.0\n",
"vary_parameter('asperity_stddev', [0.01, 0.1, 1.0], samples_vary_in='asperity')"
"vary_parameter('asperity', [(1., 0.01), (1., 0.1), (1., 1.)], samples_vary_in='asperity')\n",
"cf_x_fluct_pars['asperity'] = (1., 1e-16)"
]
},
{
......@@ -406,10 +401,10 @@
"outputs": [],
"source": [
"# Reset model to neutral\n",
"cf_x_fluct_pars['fluctuations_mean'] = 1e-3\n",
"cf_x_fluct_pars['flexibility_mean'] = 1e-3\n",
"cf_x_fluct_pars['asperity_mean'] = 1e-3\n",
"cf_x_fluct_pars['loglogavgslope_mean'] = 1e-3"
"cf_x_fluct_pars['fluctuations'] = (1e-3, 1e-16)\n",
"cf_x_fluct_pars['flexibility'] = (1e-3, 1e-16)\n",
"cf_x_fluct_pars['asperity'] = (1e-3, 1e-16)\n",
"cf_x_fluct_pars['loglogavgslope'] = (1e-3, 1e-16)"
]
},
{
......@@ -425,15 +420,15 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"## The `offset_std_` parameters of `CorrelatedFieldMaker.make()`\n",
"## The `offset_std` parameters of `CorrelatedFieldMaker.make()`\n",
"\n",
"Variation of the global offset of the field are modelled as being log-normally distributed.\n",
"See `The Moment-Matched Log-Normal Distribution` above for details.\n",
"\n",
"The `offset_std_mean` parameter sets how much NIFTy will vary the offset *on average*.\\\n",
"The `offset_std_std` parameters defines the with and shape of the offset variation distribution.\n",
"The `offset_std[0]` parameter sets how much NIFTy will vary the offset *on average*.\\\n",
"The `offset_std[1]` parameters defines the with and shape of the offset variation distribution.\n",
"\n",
"#### `offset_std_mean`:"
"#### `offset_std` mean:"
]
},
{
......@@ -442,14 +437,14 @@
"metadata": {},
"outputs": [],
"source": [
"vary_parameter('offset_std_mean', [1e-16, 0.5, 2.], samples_vary_in='xi')"
"vary_parameter('offset_std', [(1e-16, 1e-16), (0.5, 1e-16), (2., 1e-16)], samples_vary_in='xi')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### `offset_std_std`:"
"#### `offset_std` std:"
]
},
{
......@@ -458,8 +453,7 @@
"metadata": {},
"outputs": [],
"source": [
"cf_make_pars['offset_std_mean'] = 1.0\n",
"vary_parameter('offset_std_std', [0.01, 0.1, 1.0], samples_vary_in='zeromode')"
"vary_parameter('offset_std', [(1., 0.01), (1., 0.1), (1., 1.)], samples_vary_in='zeromode')"
]
}
],
......@@ -479,7 +473,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.2"
"version": "3.8.3"
}
},
"nbformat": 4,
......
......@@ -73,10 +73,10 @@ def main():
sp2 = ift.RGSpace(npix2)
# Set up signal model
cfmaker = ift.CorrelatedFieldMaker.make(0., 1e-2, 1e-6, '')
cfmaker.add_fluctuations(sp1, 0.1, 1e-2, 1, .1, .01, .5, -2, 1., 'amp1')
cfmaker.add_fluctuations(sp2, 0.1, 1e-2, 1, .1, .01, .5,
-1.5, .5, 'amp2')
cfmaker = ift.CorrelatedFieldMaker.make(0., (1e-2, 1e-6), '')
cfmaker.add_fluctuations(sp1, (0.1, 1e-2), (1, .1), (.01, .5), (-2, 1.), 'amp1')
cfmaker.add_fluctuations(sp2, (0.1, 1e-2), (1, .1), (.01, .5),
(-1.5, .5), 'amp2')
correlated_field = cfmaker.finalize()
A1 = cfmaker.normalized_amplitudes[0]
......
......@@ -92,7 +92,7 @@ from .library.correlated_fields_simple import SimpleCorrelatedField
from . import extra
from .utilities import memo, frozendict
from .utilities import memo, frozendict, myassert
from .logger import logger
......
......@@ -18,7 +18,6 @@
from itertools import combinations
import numpy as np
from numpy.testing import assert_
from .domain_tuple import DomainTuple
from .field import Field
......@@ -29,6 +28,7 @@ from .operators.energy_operators import EnergyOperator
from .operators.linear_operator import LinearOperator
from .operators.operator import Operator
from .sugar import from_random
from .utilities import myassert
__all__ = ["check_linear_operator", "check_operator",
"assert_allclose"]
......@@ -137,20 +137,6 @@ def assert_equal(f1, f2):
assert_equal(val, f2[key])
def _nozero(fld):
if isinstance(fld, Field):
return np.testing.assert_((fld != 0).s_all())
for val in fld.values():
_nozero(val)
def _allzero(fld):
if isinstance(fld, Field):
return np.testing.assert_((fld == 0.).s_all())
for val in fld.values():
_allzero(val)
def _adjoint_implementation(op, domain_dtype, target_dtype, atol, rtol,
only_r_linear):
needed_cap = op.TIMES | op.ADJOINT_TIMES
......@@ -206,32 +192,32 @@ def _domain_check_linear(op, domain_dtype=None, inp=None):
inp = from_random(op.domain, "normal", dtype=domain_dtype)
elif inp is None:
raise ValueError('Need to specify either dtype or inp')
assert_(inp.domain is op.domain)
assert_(op(inp).domain is op.target)
myassert(inp.domain is op.domain)
myassert(op(inp).domain is op.target)
def _domain_check_nonlinear(op, loc):
_domain_check(op)
assert_(isinstance(loc, (Field, MultiField)))
assert_(loc.domain is op.domain)
myassert(isinstance(loc, (Field, MultiField)))
myassert(loc.domain is op.domain)
for wm in [False, True]:
lin = Linearization.make_var(loc, wm)
reslin = op(lin)
assert_(lin.domain is op.domain)
assert_(lin.target is op.domain)
assert_(lin.val.domain is lin.domain)
assert_(reslin.domain is op.domain)
assert_(reslin.target is op.target)
assert_(reslin.val.domain is reslin.target)
assert_(reslin.target is op.target)
assert_(reslin.jac.domain is reslin.domain)
assert_(reslin.jac.target is reslin.target)
assert_(lin.want_metric == reslin.want_metric)
myassert(lin.domain is op.domain)
myassert(lin.target is op.domain)
myassert(lin.val.domain is lin.domain)
myassert(reslin.domain is op.domain)
myassert(reslin.target is op.target)
myassert(reslin.val.domain is reslin.target)
myassert(reslin.target is op.target)
myassert(reslin.jac.domain is reslin.domain)
myassert(reslin.jac.target is reslin.target)
myassert(lin.want_metric == reslin.want_metric)
_domain_check_linear(reslin.jac, inp=loc)
_domain_check_linear(reslin.jac.adjoint, inp=reslin.jac(loc))
if reslin.metric is not None:
assert_(reslin.metric.domain is reslin.metric.target)
assert_(reslin.metric.domain is op.domain)
myassert(reslin.metric.domain is reslin.metric.target)
myassert(reslin.metric.domain is op.domain)
def _domain_check(op):
......
......@@ -209,13 +209,13 @@ class _Amplitude(Operator):
loglogavgslope, azm, totvol, key, dofdex):
"""
fluctuations > 0
flexibility > 0
asperity > 0
flexibility > 0 or None
asperity > 0 or None
loglogavgslope probably negative
"""
assert isinstance(fluctuations, Operator)
assert isinstance(flexibility, Operator)
assert isinstance(asperity, Operator)
assert isinstance(flexibility, Operator) or flexibility is None
assert isinstance(asperity, Operator) or asperity is None
assert isinstance(loglogavgslope, Operator)
if len(dofdex) > 0:
......@@ -240,43 +240,53 @@ class _Amplitude(Operator):
ps_expander = ContractionOperator(twolog.target, spaces=space).adjoint
# Prepare constant fields
foo = np.zeros(shp)
foo[0] = foo[1] = np.sqrt(_log_vol(target[space]))
vflex = DiagonalOperator(makeField(dom[space], foo), dom, space)
vflex = np.zeros(shp)
vflex[0] = vflex[1] = np.sqrt(_log_vol(target[space]))
vflex = DiagonalOperator(makeField(dom[space], vflex), dom, space)
foo = np.zeros(shp, dtype=np.float64)
foo[0] += 1
vasp = DiagonalOperator(makeField(dom[space], foo), dom, space)
vasp = np.zeros(shp, dtype=np.float64)
vasp[0] += 1
vasp = DiagonalOperator(makeField(dom[space], vasp), dom, space)
foo = np.ones(shp)
foo[0] = _log_vol(target[space])**2/12.
shift = DiagonalOperator(makeField(dom[space], foo), dom, space)
shift = np.ones(shp)
shift[0] = _log_vol(target[space])**2 / 12.
shift = DiagonalOperator(makeField(dom[space], shift), dom, space)
shift = shift(full(shift.domain, 1))
vslope = DiagonalOperator(
makeField(target[space], _relative_log_k_lengths(target[space])),
target, space)
foo, bar = [np.zeros(target[space].shape) for _ in range(2)]
bar[1:] = foo[0] = totvol
vol0, vol1 = [np.zeros(target[space].shape) for _ in range(2)]
vol1[1:] = vol0[0] = totvol
vol0, vol1 = [
DiagonalOperator(makeField(target[space], aa), target, space)
for aa in (foo, bar)
for aa in (vol0, vol1)
]
# Prepare fields for Adder
shift, vol0 = [op(full(op.domain, 1)) for op in (shift, vol0)]
vol0 = vol0(full(vol0.domain, 1))
# End prepare constant fields
slope = vslope @ ps_expander @ loglogavgslope
sig_flex = vflex @ expander @ flexibility
sig_asp = vasp @ expander @ asperity
sig_flex = vflex @ expander @ flexibility if flexibility is not None else None
sig_asp = vasp @ expander @ asperity if asperity is not None else None
sig_fluc = vol1 @ ps_expander @ fluctuations
sig_fluc = vol1 @ ps_expander @ fluctuations
xi = ducktape(dom, None, key)
sigma = sig_flex*(Adder(shift) @ sig_asp).ptw("sqrt")
smooth = _SlopeRemover(target, space) @ twolog @ (sigma*xi)
op = _Normalization(target, space) @ (slope + smooth)
if sig_asp is None and sig_flex is None:
op = _Normalization(target, space) @ slope
elif sig_asp is None:
xi = ducktape(dom, None, key)
sigma = DiagonalOperator(shift.ptw("sqrt"), dom, space) @ sig_flex
smooth = _SlopeRemover(target, space) @ twolog @ (sigma * xi)
op = _Normalization(target, space) @ (slope + smooth)
elif sig_flex is None:
raise ValueError("flexibility may not be disabled on its own")
else:
xi = ducktape(dom, None, key)
sigma = sig_flex * (Adder(shift) @ sig_asp).ptw("sqrt")
smooth = _SlopeRemover(target, space) @ twolog @ (sigma * xi)
op = _Normalization(target, space) @ (slope + smooth)
if N_copies > 0:
op = Distributor @ op
sig_fluc = Distributor @ sig_fluc
......@@ -301,7 +311,7 @@ class _Amplitude(Operator):
class CorrelatedFieldMaker:
"""Constrution helper for hirarchical correlated field models.
"""Construction helper for hierarchical correlated field models.
The correlated field models are parametrized by creating
power spectrum operators ("amplitudes") via calls to
......@@ -347,18 +357,16 @@ class CorrelatedFieldMaker:
self._total_N = total_N
@staticmethod
def make(offset_mean, offset_std_mean, offset_std_std, prefix, total_N=0,
dofdex=None):
def make(offset_mean, offset_std, prefix, total_N=0, dofdex=None):
"""Returns a CorrelatedFieldMaker object.
Parameters
----------
offset_mean : float
Mean offset from zero of the correlated field to be made.
offset_std_mean : float
Mean standard deviation of the offset.
offset_std_std : float
Standard deviation of the stddev of the offset.
offset_std : tuple of float
Mean standard deviation and standard deviation of the standard
deviation of the offset. No, this is not a word duplication.
prefix : string
Prefix to the names of the domains of the cf operator to be made.
This determines the names of the operator domain.
......@@ -371,7 +379,7 @@ class CorrelatedFieldMaker:
An integer array specifying the zero mode models used if
total_N > 1. It needs to have length of total_N. If total_N=3 and
dofdex=[0,0,1], that means that two models for the zero mode are
instanciated; the first one is used for the first and second
instantiated; the first one is used for the first and second
field model and the second is used for the third field model.
*If not specified*, use the same zero mode model for all
constructed field models.
......@@ -381,22 +389,19 @@ class CorrelatedFieldMaker:
elif len(dofdex) != total_N:
raise ValueError("length of dofdex needs to match total_N")
N = max(dofdex) + 1 if total_N > 0 else 0
zm = LognormalTransform(offset_std_mean, offset_std_std,
prefix + 'zeromode', N)
if len(offset_std) != 2:
raise TypeError
zm = LognormalTransform(*offset_std, prefix + 'zeromode', N)
if total_N > 0:
zm = _Distributor(dofdex, zm.target, UnstructuredDomain(total_N)) @ zm
return CorrelatedFieldMaker(offset_mean, zm, prefix, total_N)
def add_fluctuations(self,
target_subdomain,
fluctuations_mean,
fluctuations_stddev,
flexibility_mean,
flexibility_stddev,
asperity_mean,
asperity_stddev,
loglogavgslope_mean,
loglogavgslope_stddev,
fluctuations,
flexibility,
asperity,
loglogavgslope,
prefix='',
index=None,
dofdex=None,
......@@ -411,8 +416,8 @@ class CorrelatedFieldMaker:
used on the target field subdomain `target_subdomain`.
It is assembled as the sum of a power law component
(linear slope in log-log power-frequency-space),
a smooth varying component (integrated wiener process) and
a ragged componenent (unintegrated wiener process).
a smooth varying component (integrated Wiener process) and
a ragged component (un-integrated Wiener process).
Multiple calls to `add_fluctuations` are possible, in which case
the constructed field will have the outer product of the individual
......@@ -424,14 +429,14 @@ class CorrelatedFieldMaker:
:class:`~nifty7.domain_tuple.DomainTuple`
Target subdomain on which the correlation structure defined
in this call should hold.
fluctuations_{mean,stddev} : float
fluctuations : tuple of float
Total spectral energy -> Amplitude of the fluctuations
flexibility_{mean,stddev} : float
flexibility : tuple of float or None
Amplitude of the non-power-law power spectrum component
asperity_{mean,stddev} : float
asperity : tuple of float or None
Roughness of the non-power-law power spectrum component
Used to accomodate single frequency peaks
loglogavgslope_{mean,stddev} : float
Used to accommodate single frequency peaks