MultiSmoothSuperellipsoidIC Class Reference

MultismoothSuperellipsoidIC creates multiple SmoothSuperellipsoid (number = numbub) that are randomly positioned around the domain, with a minimum spacing equal to bubspac. More...

#include <MultiSmoothSuperellipsoidIC.h>

Inheritance diagram for MultiSmoothSuperellipsoidIC:

Public Member Functions
	MultiSmoothSuperellipsoidIC (const InputParameters &parameters)
virtual void	initialSetup ()
virtual Real	value (const Point &p)
virtual RealGradient	gradient (const Point &p)

Protected Member Functions
virtual void	computeSuperellipsoidSemiaxes ()
virtual void	computeSuperellipsoidCenters ()
virtual void	computeSuperellipsoidExponents ()
virtual bool	ellipsoidsOverlap (unsigned int i, unsigned int j)
virtual bool	checkExtremes (unsigned int i, unsigned int j)
virtual Real	computeSuperellipsoidValue (const Point &p, const Point &center, Real a, Real b, Real c, Real n)
virtual Real	computeSuperellipsoidInverseValue (const Point &p, const Point &center, Real a, Real b, Real c, Real n)
RealGradient	computeSuperellipsoidGradient (const Point &p, const Point &center, Real a, Real b, Real c, Real n)

Protected Attributes
const unsigned int	_max_num_tries
unsigned int	_gk
const MooseEnum	_semiaxis_variation_type
const bool	_prevent_overlap
const bool	_check_extremes
const bool	_vary_axes_independently
Point	_bottom_left
Point	_top_right
Point	_range
std::vector< unsigned int >	_numbub
std::vector< Real >	_bubspac
std::vector< Real >	_exponent
std::vector< Real >	_semiaxis_a
std::vector< Real >	_semiaxis_b
std::vector< Real >	_semiaxis_c
std::vector< Real >	_semiaxis_a_variation
std::vector< Real >	_semiaxis_b_variation
std::vector< Real >	_semiaxis_c_variation
MooseMesh &	_mesh
Real	_invalue
Real	_outvalue
Real	_nestedvalue
Real	_int_width
bool	_zero_gradient
unsigned int	_num_dim
std::vector< Point >	_centers
std::vector< Real >	_as
std::vector< Real >	_bs
std::vector< Real >	_cs
std::vector< Real >	_ns
MooseRandom	_random

Detailed Description

MultismoothSuperellipsoidIC creates multiple SmoothSuperellipsoid (number = numbub) that are randomly positioned around the domain, with a minimum spacing equal to bubspac.

Definition at line 25 of file MultiSmoothSuperellipsoidIC.h.

Constructor & Destructor Documentation

MultiSmoothSuperellipsoidIC()

MultiSmoothSuperellipsoidIC::MultiSmoothSuperellipsoidIC

(

const InputParameters &

parameters

)

Definition at line 81 of file MultiSmoothSuperellipsoidIC.C.

  : SmoothSuperellipsoidBaseIC(parameters),
    _max_num_tries(getParam<unsigned int>("max_num_tries")),
    _semiaxis_variation_type(getParam<MooseEnum>("semiaxis_variation_type")),
    _prevent_overlap(getParam<bool>("prevent_overlap")),
    _check_extremes(getParam<bool>("check_extremes")),
    _vary_axes_independently(getParam<bool>("vary_axes_independently")),
    _numbub(parameters.get<std::vector<unsigned int>>("numbub")),
    _bubspac(parameters.get<std::vector<Real>>("bubspac")),
    _exponent(parameters.get<std::vector<Real>>("exponent")),
    _semiaxis_a(parameters.get<std::vector<Real>>("semiaxis_a")),
    _semiaxis_b(parameters.get<std::vector<Real>>("semiaxis_b")),
    _semiaxis_c(parameters.get<std::vector<Real>>("semiaxis_c")),
    _semiaxis_a_variation(parameters.get<std::vector<Real>>("semiaxis_a_variation")),
    _semiaxis_b_variation(parameters.get<std::vector<Real>>("semiaxis_b_variation")),
    _semiaxis_c_variation(parameters.get<std::vector<Real>>("semiaxis_c_variation"))
{
}

Member Function Documentation

checkExtremes()

bool MultiSmoothSuperellipsoidIC::checkExtremes ( unsigned int  i, unsigned int  j  )

protectedvirtual

Definition at line 279 of file MultiSmoothSuperellipsoidIC.C.

{
  Point tmp_p;
  for (unsigned int pc = 0; pc < 6; pc++)
  {
    tmp_p = _centers[j];
    // Find extremes along semiaxis of candidate ellipsoids
    if (pc == 0)
      tmp_p(0) -= _as[j];
    else if (pc == 1)
      tmp_p(0) += _as[j];
    else if (pc == 2)
      tmp_p(1) -= _bs[j];
    else if (pc == 3)
      tmp_p(1) += _bs[j];
    else if (pc == 4)
      tmp_p(2) -= _cs[j];
    else
      tmp_p(2) += _cs[j];
 
    const Point dist_vec = _mesh.minPeriodicVector(_var.number(), _centers[i], tmp_p);
    const Real dist = dist_vec.norm();
 
    // Handle this case independently because we cannot calculate polar angles at this point
    if (MooseUtils::absoluteFuzzyEqual(dist, 0.0))
      return true;
 
    // calculate rmn = r^(-n), replacing sin, cos functions with distances
    Real rmn = (std::pow(std::abs(dist_vec(0) / dist / _as[i]), _ns[i]) +
                std::pow(std::abs(dist_vec(1) / dist / _bs[i]), _ns[i]) +
                std::pow(std::abs(dist_vec(2) / dist / _cs[i]), _ns[i]));
    Real r = std::pow(rmn, (-1.0 / _ns[i]));
 
    if (dist < r)
      return true;
  }
 
  return false;
}

Referenced by ellipsoidsOverlap().

computeSuperellipsoidCenters()

void MultiSmoothSuperellipsoidIC::computeSuperellipsoidCenters ( )

protectedvirtual

Implements SmoothSuperellipsoidBaseIC.

Definition at line 185 of file MultiSmoothSuperellipsoidIC.C.

{
  unsigned int start = _centers.size();
  _centers.resize(start + _numbub[_gk]);
 
  for (unsigned int i = start; i < _centers.size(); i++)
  {
    // Vary circle center positions
    unsigned int num_tries = 0;
    while (num_tries < _max_num_tries)
    {
      num_tries++;
 
      RealTensorValue ran;
      ran(0, 0) = _random.rand(_tid);
      ran(1, 1) = _random.rand(_tid);
      ran(2, 2) = _random.rand(_tid);
 
      _centers[i] = _bottom_left + ran * _range;
 
      for (unsigned int j = 0; j < i; ++j)
        if (_mesh.minPeriodicDistance(_var.number(), _centers[i], _centers[j]) < _bubspac[_gk] ||
            ellipsoidsOverlap(i, j))
          goto fail;
 
      // accept the position of the new center
      goto accept;
 
    // retry a new position until tries are exhausted
    fail:
      continue;
    }
 
    if (num_tries == _max_num_tries)
      mooseError("max_num_tries reached in 'MultiSmoothSuperellipsoidIC'.");
 
  accept:
    continue;
  }
}

computeSuperellipsoidExponents()

void MultiSmoothSuperellipsoidIC::computeSuperellipsoidExponents ( )

protectedvirtual

Implements SmoothSuperellipsoidBaseIC.

Definition at line 227 of file MultiSmoothSuperellipsoidIC.C.

{
  unsigned int start = _ns.size();
  _ns.resize(start + _numbub[_gk]);
 
  for (unsigned int i = start; i < _ns.size(); ++i)
    _ns[i] = _exponent[_gk];
}

computeSuperellipsoidGradient()

RealGradient SmoothSuperellipsoidBaseIC::computeSuperellipsoidGradient ( const Point &  p, const Point &  center, Real  a, Real  b, Real  c, Real  n  )

protectedinherited

Definition at line 195 of file SmoothSuperellipsoidBaseIC.C.

{
  Point l_center = center;
  Point l_p = p;
  // Compute the distance between the current point and the center
  Real dist = _mesh.minPeriodicDistance(_var.number(), l_p, l_center);
 
  // When dist is 0 we are exactly at the center of the superellipsoid so return 0
  // Handle this case independently because we cannot calculate polar angles at this point
  if (dist == 0.0)
    return 0.0;
 
  // Compute the distance r from the center of the superellipsoid to its outside edge
  // along the vector from the center to the current point
  // This uses the equation for a superellipse in polar coordinates and substitutes
  // distances for sin, cos functions
  Point dist_vec = _mesh.minPeriodicVector(_var.number(), center, p);
  // First calculate rmn = r^(-n)
  Real rmn = (std::pow(std::abs(dist_vec(0) / dist / a), n) +
              std::pow(std::abs(dist_vec(1) / dist / b), n) +
              std::pow(std::abs(dist_vec(2) / dist / c), n));
  // Then calculate r from rmn
  Real r = std::pow(rmn, (-1.0 / n));
 
  Real DvalueDr = 0.0;
 
  if (dist < r + _int_width / 2.0 && dist > r - _int_width / 2.0) // in interfacial region
  {
    Real int_pos = (dist - r + _int_width / 2.0) / _int_width;
    Real Dint_posDr = 1.0 / _int_width;
    DvalueDr = Dint_posDr * (_invalue - _outvalue) *
               (-std::sin(int_pos * libMesh::pi) * libMesh::pi) / 2.0;
  }
 
  return dist_vec * (DvalueDr / dist);
}

Referenced by SmoothSuperellipsoidBaseIC::gradient().

computeSuperellipsoidInverseValue()

Real SmoothSuperellipsoidBaseIC::computeSuperellipsoidInverseValue ( const Point &  p, const Point &  center, Real  a, Real  b, Real  c, Real  n  )

protectedvirtualinherited

Definition at line 155 of file SmoothSuperellipsoidBaseIC.C.

{
  Point l_center = center;
  Point l_p = p;
  // Compute the distance between the current point and the center
  Real dist = _mesh.minPeriodicDistance(_var.number(), l_p, l_center);
 
  // When dist is 0 we are exactly at the center of the superellipsoid so return _invalue
  // Handle this case independently because we cannot calculate polar angles at this point
  if (dist == 0.0)
    return _nestedvalue;
 
  // Compute the distance r from the center of the superellipsoid to its outside edge
  // along the vector from the center to the current point
  // This uses the equation for a superellipse in polar coordinates and substitutes
  // distances for sin, cos functions
  Point dist_vec = _mesh.minPeriodicVector(_var.number(), center, p);
 
  // First calculate rmn = r^(-n), replacing sin, cos functions with distances
  Real rmn = (std::pow(std::abs(dist_vec(0) / dist / a), n) +
              std::pow(std::abs(dist_vec(1) / dist / b), n) +
              std::pow(std::abs(dist_vec(2) / dist / c), n));
  // Then calculate r from rmn
  Real r = std::pow(rmn, (-1.0 / n));
 
  Real value = _invalue;
 
  if (dist <= r - _int_width / 2.0) // Reversing inside and outside values
    value = _nestedvalue;
  else if (dist < r + _int_width / 2.0) // Smooth interface
  {
    Real int_pos = (dist - r + _int_width / 2.0) / _int_width;
    value = _invalue + (_nestedvalue - _invalue) * (1.0 + std::cos(int_pos * libMesh::pi)) / 2.0;
  }
 
  return value;
}

Referenced by BimodalInverseSuperellipsoidsIC::value().

computeSuperellipsoidSemiaxes()

void MultiSmoothSuperellipsoidIC::computeSuperellipsoidSemiaxes ( )

protectedvirtual

Implements SmoothSuperellipsoidBaseIC.

Definition at line 138 of file MultiSmoothSuperellipsoidIC.C.

{
  Real randnum;
  unsigned int start = _as.size();
  _as.resize(start + _numbub[_gk]);
  _bs.resize(start + _numbub[_gk]);
  _cs.resize(start + _numbub[_gk]);
 
  for (unsigned int i = start; i < _as.size(); i++)
  {
    switch (_semiaxis_variation_type)
    {
      case 0: // Uniform distrubtion
        randnum = _random.rand(_tid);
        _as[i] = _semiaxis_a[_gk] * (1.0 + (1.0 - 2.0 * randnum) * _semiaxis_a_variation[_gk]);
        _bs[i] = _semiaxis_b[_gk] *
                 (1.0 + (1.0 - 2.0 * (_vary_axes_independently ? _random.rand(_tid) : randnum)) *
                            _semiaxis_b_variation[_gk]);
        _cs[i] = _semiaxis_c[_gk] *
                 (1.0 + (1.0 - 2.0 * (_vary_axes_independently ? _random.rand(_tid) : randnum)) *
                            _semiaxis_c_variation[_gk]);
        break;
 
      case 1: // Normal distribution
        randnum = _random.randNormal(_tid, 0, 1);
        _as[i] = _semiaxis_a[_gk] + (randnum * _semiaxis_a_variation[_gk]);
        _bs[i] = _semiaxis_b[_gk] +
                 ((_vary_axes_independently ? _random.randNormal(_tid, 0, 1) : randnum) *
                  _semiaxis_b_variation[_gk]);
        _cs[i] = _semiaxis_c[_gk] +
                 ((_vary_axes_independently ? _random.randNormal(_tid, 0, 1) : randnum) *
                  _semiaxis_c_variation[_gk]);
        break;
 
      case 2: // No variation
        _as[i] = _semiaxis_a[_gk];
        _bs[i] = _semiaxis_b[_gk];
        _cs[i] = _semiaxis_c[_gk];
    }
 
    _as[i] = _as[i] < 0.0 ? 0.0 : _as[i];
    _bs[i] = _bs[i] < 0.0 ? 0.0 : _bs[i];
    _cs[i] = _cs[i] < 0.0 ? 0.0 : _cs[i];
  }
}

computeSuperellipsoidValue()

Real SmoothSuperellipsoidBaseIC::computeSuperellipsoidValue ( const Point &  p, const Point &  center, Real  a, Real  b, Real  c, Real  n  )

protectedvirtualinherited

Definition at line 114 of file SmoothSuperellipsoidBaseIC.C.

{
  Point l_center = center;
  Point l_p = p;
  // Compute the distance between the current point and the center
  Real dist = _mesh.minPeriodicDistance(_var.number(), l_p, l_center);
 
  // When dist is 0 we are exactly at the center of the superellipsoid so return _invalue
  // Handle this case independently because we cannot calculate polar angles at this point
  if (dist == 0.0)
    return _invalue;
 
  // Compute the distance r from the center of the superellipsoid to its outside edge
  // along the vector from the center to the current point
  // This uses the equation for a superellipse in polar coordinates and substitutes
  // distances for sin, cos functions
  Point dist_vec = _mesh.minPeriodicVector(_var.number(), center, p);
 
  // First calculate rmn = r^(-n), replacing sin, cos functions with distances
  Real rmn = (std::pow(std::abs(dist_vec(0) / dist / a), n) +
              std::pow(std::abs(dist_vec(1) / dist / b), n) +
              std::pow(std::abs(dist_vec(2) / dist / c), n));
  // Then calculate r from rmn
  Real r = std::pow(rmn, (-1.0 / n));
 
  Real value = _outvalue; // Outside superellipsoid
 
  if (dist <= r - _int_width / 2.0) // Inside superellipsoid
    value = _invalue;
  else if (dist < r + _int_width / 2.0) // Smooth interface
  {
    Real int_pos = (dist - r + _int_width / 2.0) / _int_width;
    value = _outvalue + (_invalue - _outvalue) * (1.0 + std::cos(int_pos * libMesh::pi)) / 2.0;
  }
 
  return value;
}

Referenced by SmoothSuperellipsoidBaseIC::gradient(), SmoothSuperellipsoidBaseIC::value(), and BimodalInverseSuperellipsoidsIC::value().

ellipsoidsOverlap()

bool MultiSmoothSuperellipsoidIC::ellipsoidsOverlap ( unsigned int  i, unsigned int  j  )

protectedvirtual

Definition at line 237 of file MultiSmoothSuperellipsoidIC.C.

{
  // Check for overlap between centers
  const Point dist_vec = _mesh.minPeriodicVector(_var.number(), _centers[i], _centers[j]);
  const Real dist = dist_vec.norm();
 
  // Handle this case independently because we cannot calculate polar angles at this point
  if (MooseUtils::absoluteFuzzyEqual(dist, 0.0))
    return true;
 
  // Compute the distance r from the center of the superellipsoid to its outside edge
  // along the vector from the center to the current point
  // This uses the equation for a superellipse in polar coordinates and substitutes
  // distances for sin, cos functions
  Real rmn;
 
  // calculate rmn = r^(-n), replacing sin, cos functions with distances
  rmn = (std::pow(std::abs(dist_vec(0) / dist / _as[i]), _ns[i]) +
         std::pow(std::abs(dist_vec(1) / dist / _bs[i]), _ns[i]) +
         std::pow(std::abs(dist_vec(2) / dist / _cs[i]), _ns[i]));
  // calculate r2 from rmn
  const Real r1 = std::pow(rmn, (-1.0 / _ns[i]));
 
  // calculate rmn = r^(-n), replacing sin, cos functions with distances
  rmn = (std::pow(std::abs(dist_vec(0) / dist / _as[j]), _ns[j]) +
         std::pow(std::abs(dist_vec(1) / dist / _bs[j]), _ns[j]) +
         std::pow(std::abs(dist_vec(2) / dist / _cs[j]), _ns[j]));
  const Real r2 = std::pow(rmn, (-1.0 / _ns[j]));
 
  if (dist < r1 + r2)
    return true;
 
  // Check for overlap between extremes of new ellipsoid candidate and the center
  // of accepted ellisoids if _check_extremes enabled
  if (_check_extremes)
    return checkExtremes(i, j) || checkExtremes(j, i);
 
  // otherwise no overlap has been detected
  return false;
}

Referenced by computeSuperellipsoidCenters().

gradient()

RealGradient SmoothSuperellipsoidBaseIC::gradient ( const Point &  p )

virtualinherited

Definition at line 89 of file SmoothSuperellipsoidBaseIC.C.

{
  if (_zero_gradient)
    return 0.0;
 
  RealGradient gradient = 0.0;
  Real value = _outvalue;
  Real val2 = 0.0;
 
  for (unsigned int ellip = 0; ellip < _centers.size(); ++ellip)
  {
    val2 = computeSuperellipsoidValue(
        p, _centers[ellip], _as[ellip], _bs[ellip], _cs[ellip], _ns[ellip]);
    if ((val2 > value && _invalue > _outvalue) || (val2 < value && _outvalue > _invalue))
    {
      value = val2;
      gradient = computeSuperellipsoidGradient(
          p, _centers[ellip], _as[ellip], _bs[ellip], _cs[ellip], _ns[ellip]);
    }
  }
 
  return gradient;
}

initialSetup()

void MultiSmoothSuperellipsoidIC::initialSetup ( )

virtual

Reimplemented from SmoothSuperellipsoidBaseIC.

Definition at line 101 of file MultiSmoothSuperellipsoidIC.C.

{
  unsigned int nv = _numbub.size();
 
  if (nv != _bubspac.size() || nv != _exponent.size() || nv != _semiaxis_a.size() ||
      nv != _semiaxis_b.size() || nv != _semiaxis_c.size())
    mooseError("Vectors for numbub, bubspac, exponent, semiaxis_a, semiaxis_b, and semiaxis_c must "
               "be the same size.");
 
  if (_semiaxis_variation_type != 2 &&
      (nv != _semiaxis_a_variation.size() || nv != _semiaxis_b_variation.size() ||
       nv != _semiaxis_c_variation.size()))
    mooseError("Vectors for numbub, semiaxis_a_variation, semiaxis_b_variation, and "
               "semiaxis_c_variation must be the same size.");
 
  if (_semiaxis_variation_type == 2 &&
      (_semiaxis_a_variation.size() > 0 || _semiaxis_b_variation.size() > 0 ||
       _semiaxis_c_variation.size() > 0))
    mooseWarning(
        "Values were provided for semiaxis_a/b/c_variation but semiaxis_variation_type is set "
        "to 'none' in 'MultiSmoothSuperellipsoidIC'.");
 
  for (_gk = 0; _gk < nv; ++_gk)
  {
    // Set up domain bounds with mesh tools
    for (unsigned int i = 0; i < LIBMESH_DIM; i++)
    {
      _bottom_left(i) = _mesh.getMinInDimension(i);
      _top_right(i) = _mesh.getMaxInDimension(i);
    }
    _range = _top_right - _bottom_left;
 
    SmoothSuperellipsoidBaseIC::initialSetup();
  }
}

value()

Real SmoothSuperellipsoidBaseIC::value ( const Point &  p )

virtualinherited

Reimplemented in BimodalInverseSuperellipsoidsIC.

Definition at line 72 of file SmoothSuperellipsoidBaseIC.C.

{
  Real value = _outvalue;
  Real val2 = 0.0;
 
  for (unsigned int ellip = 0; ellip < _centers.size() && value != _invalue; ++ellip)
  {
    val2 = computeSuperellipsoidValue(
        p, _centers[ellip], _as[ellip], _bs[ellip], _cs[ellip], _ns[ellip]);
    if ((val2 > value && _invalue > _outvalue) || (val2 < value && _outvalue > _invalue))
      value = val2;
  }
 
  return value;
}

Referenced by SmoothSuperellipsoidBaseIC::computeSuperellipsoidInverseValue(), SmoothSuperellipsoidBaseIC::computeSuperellipsoidValue(), and SmoothSuperellipsoidBaseIC::gradient().

Member Data Documentation

_as

std::vector<Real> SmoothSuperellipsoidBaseIC::_as

protectedinherited

Definition at line 61 of file SmoothSuperellipsoidBaseIC.h.

Referenced by checkExtremes(), BimodalSuperellipsoidsIC::computeSuperellipsoidCenters(), BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters(), SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidSemiaxes(), SmoothSuperellipsoidIC::computeSuperellipsoidSemiaxes(), computeSuperellipsoidSemiaxes(), BimodalSuperellipsoidsIC::computeSuperellipsoidSemiaxes(), ellipsoidsOverlap(), SmoothSuperellipsoidBaseIC::gradient(), SmoothSuperellipsoidBaseIC::initialSetup(), SmoothSuperellipsoidBaseIC::value(), and BimodalInverseSuperellipsoidsIC::value().

_bottom_left

Point MultiSmoothSuperellipsoidIC::_bottom_left

protected

Definition at line 48 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidCenters(), and initialSetup().

_bs

std::vector<Real> SmoothSuperellipsoidBaseIC::_bs

protectedinherited

Definition at line 62 of file SmoothSuperellipsoidBaseIC.h.

Referenced by checkExtremes(), BimodalSuperellipsoidsIC::computeSuperellipsoidCenters(), BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters(), SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidSemiaxes(), SmoothSuperellipsoidIC::computeSuperellipsoidSemiaxes(), computeSuperellipsoidSemiaxes(), BimodalSuperellipsoidsIC::computeSuperellipsoidSemiaxes(), ellipsoidsOverlap(), SmoothSuperellipsoidBaseIC::gradient(), SmoothSuperellipsoidBaseIC::initialSetup(), SmoothSuperellipsoidBaseIC::value(), and BimodalInverseSuperellipsoidsIC::value().

_bubspac

std::vector<Real> MultiSmoothSuperellipsoidIC::_bubspac

protected

Definition at line 53 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidCenters(), and initialSetup().

_centers

std::vector<Point> SmoothSuperellipsoidBaseIC::_centers

protectedinherited

Definition at line 60 of file SmoothSuperellipsoidBaseIC.h.

Referenced by checkExtremes(), SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidCenters(), SmoothSuperellipsoidIC::computeSuperellipsoidCenters(), computeSuperellipsoidCenters(), BimodalSuperellipsoidsIC::computeSuperellipsoidCenters(), BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters(), ellipsoidsOverlap(), SmoothSuperellipsoidBaseIC::gradient(), SmoothSuperellipsoidBaseIC::initialSetup(), SmoothSuperellipsoidBaseIC::value(), and BimodalInverseSuperellipsoidsIC::value().

_check_extremes

const bool MultiSmoothSuperellipsoidIC::_check_extremes

protected

Definition at line 45 of file MultiSmoothSuperellipsoidIC.h.

Referenced by ellipsoidsOverlap().

_cs

std::vector<Real> SmoothSuperellipsoidBaseIC::_cs

protectedinherited

Definition at line 63 of file SmoothSuperellipsoidBaseIC.h.

Referenced by checkExtremes(), BimodalSuperellipsoidsIC::computeSuperellipsoidCenters(), BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters(), SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidSemiaxes(), SmoothSuperellipsoidIC::computeSuperellipsoidSemiaxes(), computeSuperellipsoidSemiaxes(), BimodalSuperellipsoidsIC::computeSuperellipsoidSemiaxes(), ellipsoidsOverlap(), SmoothSuperellipsoidBaseIC::gradient(), SmoothSuperellipsoidBaseIC::initialSetup(), SmoothSuperellipsoidBaseIC::value(), and BimodalInverseSuperellipsoidsIC::value().

_exponent

std::vector<Real> MultiSmoothSuperellipsoidIC::_exponent

protected

Definition at line 54 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidExponents(), and initialSetup().

_gk

unsigned int MultiSmoothSuperellipsoidIC::_gk

protected

Definition at line 41 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidCenters(), computeSuperellipsoidExponents(), computeSuperellipsoidSemiaxes(), and initialSetup().

_int_width

Real SmoothSuperellipsoidBaseIC::_int_width

protectedinherited

Definition at line 55 of file SmoothSuperellipsoidBaseIC.h.

Referenced by SmoothSuperellipsoidBaseIC::computeSuperellipsoidGradient(), SmoothSuperellipsoidBaseIC::computeSuperellipsoidInverseValue(), and SmoothSuperellipsoidBaseIC::computeSuperellipsoidValue().

_invalue

Real SmoothSuperellipsoidBaseIC::_invalue

protectedinherited

Definition at line 52 of file SmoothSuperellipsoidBaseIC.h.

Referenced by SmoothSuperellipsoidBaseIC::computeSuperellipsoidGradient(), SmoothSuperellipsoidBaseIC::computeSuperellipsoidInverseValue(), SmoothSuperellipsoidBaseIC::computeSuperellipsoidValue(), SmoothSuperellipsoidBaseIC::gradient(), SmoothSuperellipsoidBaseIC::value(), and BimodalInverseSuperellipsoidsIC::value().

_max_num_tries

const unsigned int MultiSmoothSuperellipsoidIC::_max_num_tries

protected

Definition at line 40 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidCenters().

_mesh

MooseMesh& SmoothSuperellipsoidBaseIC::_mesh

protectedinherited

Definition at line 50 of file SmoothSuperellipsoidBaseIC.h.

Referenced by checkExtremes(), computeSuperellipsoidCenters(), BimodalSuperellipsoidsIC::computeSuperellipsoidCenters(), BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters(), SmoothSuperellipsoidBaseIC::computeSuperellipsoidGradient(), SmoothSuperellipsoidBaseIC::computeSuperellipsoidInverseValue(), SmoothSuperellipsoidBaseIC::computeSuperellipsoidValue(), ellipsoidsOverlap(), initialSetup(), and BimodalSuperellipsoidsIC::initialSetup().

_nestedvalue

Real SmoothSuperellipsoidBaseIC::_nestedvalue

protectedinherited

Definition at line 54 of file SmoothSuperellipsoidBaseIC.h.

Referenced by SmoothSuperellipsoidBaseIC::computeSuperellipsoidInverseValue().

_ns

std::vector<Real> SmoothSuperellipsoidBaseIC::_ns

protectedinherited

Definition at line 64 of file SmoothSuperellipsoidBaseIC.h.

Referenced by checkExtremes(), BimodalSuperellipsoidsIC::computeSuperellipsoidCenters(), BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters(), SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidExponents(), SmoothSuperellipsoidIC::computeSuperellipsoidExponents(), computeSuperellipsoidExponents(), BimodalSuperellipsoidsIC::computeSuperellipsoidExponents(), ellipsoidsOverlap(), SmoothSuperellipsoidBaseIC::gradient(), SmoothSuperellipsoidBaseIC::initialSetup(), SmoothSuperellipsoidBaseIC::value(), and BimodalInverseSuperellipsoidsIC::value().

_num_dim

unsigned int SmoothSuperellipsoidBaseIC::_num_dim

protectedinherited

Definition at line 58 of file SmoothSuperellipsoidBaseIC.h.

_numbub

std::vector<unsigned int> MultiSmoothSuperellipsoidIC::_numbub

protected

Definition at line 52 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidCenters(), computeSuperellipsoidExponents(), computeSuperellipsoidSemiaxes(), and initialSetup().

_outvalue

Real SmoothSuperellipsoidBaseIC::_outvalue

protectedinherited

Definition at line 53 of file SmoothSuperellipsoidBaseIC.h.

Referenced by SmoothSuperellipsoidBaseIC::computeSuperellipsoidGradient(), SmoothSuperellipsoidBaseIC::computeSuperellipsoidValue(), SmoothSuperellipsoidBaseIC::gradient(), SmoothSuperellipsoidBaseIC::value(), and BimodalInverseSuperellipsoidsIC::value().

_prevent_overlap

const bool MultiSmoothSuperellipsoidIC::_prevent_overlap

protected

Definition at line 44 of file MultiSmoothSuperellipsoidIC.h.

_random

MooseRandom SmoothSuperellipsoidBaseIC::_random

protectedinherited

Definition at line 66 of file SmoothSuperellipsoidBaseIC.h.

Referenced by computeSuperellipsoidCenters(), BimodalSuperellipsoidsIC::computeSuperellipsoidCenters(), BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters(), computeSuperellipsoidSemiaxes(), BimodalSuperellipsoidsIC::computeSuperellipsoidSemiaxes(), and SmoothSuperellipsoidBaseIC::SmoothSuperellipsoidBaseIC().

_range

Point MultiSmoothSuperellipsoidIC::_range

protected

Definition at line 50 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidCenters(), and initialSetup().

_semiaxis_a

std::vector<Real> MultiSmoothSuperellipsoidIC::_semiaxis_a

protected

Definition at line 55 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

_semiaxis_a_variation

std::vector<Real> MultiSmoothSuperellipsoidIC::_semiaxis_a_variation

protected

Definition at line 58 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

_semiaxis_b

std::vector<Real> MultiSmoothSuperellipsoidIC::_semiaxis_b

protected

Definition at line 56 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

_semiaxis_b_variation

std::vector<Real> MultiSmoothSuperellipsoidIC::_semiaxis_b_variation

protected

Definition at line 59 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

_semiaxis_c

std::vector<Real> MultiSmoothSuperellipsoidIC::_semiaxis_c

protected

Definition at line 57 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

_semiaxis_c_variation

std::vector<Real> MultiSmoothSuperellipsoidIC::_semiaxis_c_variation

protected

Definition at line 60 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

_semiaxis_variation_type

const MooseEnum MultiSmoothSuperellipsoidIC::_semiaxis_variation_type

protected

Definition at line 43 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

_top_right

Point MultiSmoothSuperellipsoidIC::_top_right

protected

Definition at line 49 of file MultiSmoothSuperellipsoidIC.h.

Referenced by initialSetup().

_vary_axes_independently

const bool MultiSmoothSuperellipsoidIC::_vary_axes_independently

protected

Definition at line 46 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes().

_zero_gradient

bool SmoothSuperellipsoidBaseIC::_zero_gradient

protectedinherited

Definition at line 56 of file SmoothSuperellipsoidBaseIC.h.

Referenced by SmoothSuperellipsoidBaseIC::gradient().

---

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

• phase_field/include/ics/MultiSmoothSuperellipsoidIC.h
• phase_field/src/ics/MultiSmoothSuperellipsoidIC.C