FourierNoise Class Reference

Generate noise using random fourier series coefficients. More...

#include <FourierNoise.h>

Inheritance diagram for FourierNoise:

Classes
struct	SeriesItem

Public Member Functions
	FourierNoise (const InputParameters &parameters)
virtual Real	value (Real, const Point &p) const override

Protected Attributes
const Real	_lambda
	selected lower lengthscale for the noise cut-off More...
std::vector< SeriesItem >	_series
	Fourier series terms. More...
Real	_scale
	amplitude factor More...
FEProblemBase &	_fe_problem
	FEProblem pointer for obtaining the current mesh. More...

Detailed Description

Generate noise using random fourier series coefficients.

Definition at line 23 of file FourierNoise.h.

Constructor & Destructor Documentation

FourierNoise()

FourierNoise::FourierNoise

(

const InputParameters &

parameters

)

Definition at line 33 of file FourierNoise.C.

  : Function(parameters),
    _lambda(getParam<Real>("lambda")),
    _fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base"))
{
  MooseRandom rng;
  rng.seed(0, getParam<unsigned int>("seed"));
 
  if (isParamValid("num_terms"))
  {
    // random terms
    _series.resize(getParam<unsigned int>("num_terms"));
    const Real scale = 2.0 * (2.0 * libMesh::pi) / _lambda;
 
    // check
    if (_series.empty())
      paramError("num_terms",
                 "If specifying the number of terms, supply a number greater than zero.");
 
    // fill terms
    for (auto & f : _series)
    {
      // get a vector with length <= 0.5
      Real r2;
      do
      {
        const Real x = rng.rand(0) - 0.5;
        const Real y = rng.rand(0) - 0.5;
        f.k = RealVectorValue(x, y, 0.0);
        r2 = f.k.norm_sq();
      } while (r2 > 0.25);
 
      // scale maximum to a wavelength of lambda
      f.k *= scale;
 
      f.c = rng.randNormal(0, 0.0, 1.0);
      f.s = rng.randNormal(0, 0.0, 1.0);
    }
  }
  else
  {
    // k-space grid resulting in periodic noise
    MooseMesh & mesh = _fe_problem.mesh();
    if (!mesh.isRegularOrthogonal())
      mooseError("Periodic Fourier Noise requires a regular orthogonal mesh.");
 
    const Real dx = 2.0 * libMesh::pi / mesh.dimensionWidth(0);
    const Real dy = 2.0 * libMesh::pi / mesh.dimensionWidth(1);
    const Real rmax = 2.0 * libMesh::pi / _lambda;
 
    const int xmax = rmax / dx;
    const int ymax = rmax / dy;
 
    const Real rmax2 = rmax * rmax;
    for (int x = 0; x < xmax; ++x)
      for (int y = -ymax; y < ymax; ++y)
        if (x > 0 || y > 0)
        {
          SeriesItem f;
          f.k = RealVectorValue(x * dx, y * dy, 0.0);
          if (f.k.norm_sq() <= rmax2)
          {
            f.c = rng.randNormal(0, 0.0, 1.0);
            f.s = rng.randNormal(0, 0.0, 1.0);
            _series.push_back(f);
          }
        }
  }
 
  _scale = std::sqrt(1.0 / _series.size());
}

Member Function Documentation

value()

Real FourierNoise::value ( Real  , const Point &  p  ) const

overridevirtual

Definition at line 106 of file FourierNoise.C.

{
  Real v = 0.0;
  for (const auto & f : _series)
    v += f.s * std::sin(p * f.k) + f.c * std::cos(p * f.k);
  return v * _scale;
}

Member Data Documentation

_fe_problem

FEProblemBase& FourierNoise::_fe_problem

protected

FEProblem pointer for obtaining the current mesh.

Definition at line 51 of file FourierNoise.h.

Referenced by FourierNoise().

_lambda

const Real FourierNoise::_lambda

protected

selected lower lengthscale for the noise cut-off

Definition at line 42 of file FourierNoise.h.

Referenced by FourierNoise().

_scale

Real FourierNoise::_scale

protected

amplitude factor

Definition at line 48 of file FourierNoise.h.

Referenced by FourierNoise(), and value().

_series

std::vector<SeriesItem> FourierNoise::_series

protected

Fourier series terms.

Definition at line 45 of file FourierNoise.h.

Referenced by FourierNoise(), and value().

---

The documentation for this class was generated from the following files:

• phase_field/include/functions/FourierNoise.h
• phase_field/src/functions/FourierNoise.C