BimodalSuperellipsoidsIC Class Reference

BimodalSuperellipsoidsIC takes a specified number of superellipsoids, each with given parameters These are intended to be the larger particles. More...

#include <BimodalSuperellipsoidsIC.h>

Inheritance diagram for BimodalSuperellipsoidsIC:

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

Protected Member Functions
virtual void	computeSuperellipsoidCenters ()
virtual void	computeSuperellipsoidSemiaxes ()
virtual void	computeSuperellipsoidExponents ()
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
Point	_bottom_left
Point	_top_right
Point	_range
std::vector< Real >	_x_positions
std::vector< Real >	_y_positions
std::vector< Real >	_z_positions
std::vector< Real >	_input_as
std::vector< Real >	_input_bs
std::vector< Real >	_input_cs
std::vector< Real >	_input_ns
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
unsigned int	_npart
	Variables to describe the randomly placed (smaller) superellipsoids. More...
Real	_small_spac
Real	_large_spac
Real	_small_a
Real	_small_b
Real	_small_c
Real	_small_n
const Real	_size_variation
const MooseEnum	_size_variation_type

Detailed Description

BimodalSuperellipsoidsIC takes a specified number of superellipsoids, each with given parameters These are intended to be the larger particles.

Then the IC creates a specified number of particles at random locations. These are the smaller particles. As each random particle is placed, it it checked to make sure it does not collide with previously placed particles (either large or small ones). Variables to describe the specified (larger) superellipsoids are inherited from the parent class.

Definition at line 30 of file BimodalSuperellipsoidsIC.h.

Constructor & Destructor Documentation

BimodalSuperellipsoidsIC()

BimodalSuperellipsoidsIC::BimodalSuperellipsoidsIC

(

const InputParameters &

parameters

)

Definition at line 54 of file BimodalSuperellipsoidsIC.C.

  : SpecifiedSmoothSuperellipsoidIC(parameters),
    _npart(getParam<unsigned int>("npart")),
    _small_spac(getParam<Real>("small_spac")),
    _large_spac(getParam<Real>("large_spac")),
    _small_a(getParam<Real>("small_a")),
    _small_b(getParam<Real>("small_b")),
    _small_c(getParam<Real>("small_c")),
    _small_n(getParam<Real>("small_n")),
    _size_variation(getParam<Real>("size_variation")),
    _size_variation_type(getParam<MooseEnum>("size_variation_type")),
    _max_num_tries(getParam<unsigned int>("numtries"))
{
}

Member Function Documentation

computeSuperellipsoidCenters()

void BimodalSuperellipsoidsIC::computeSuperellipsoidCenters ( )

protectedvirtual

Reimplemented from SpecifiedSmoothSuperellipsoidIC.

Reimplemented in BimodalInverseSuperellipsoidsIC.

Definition at line 152 of file BimodalSuperellipsoidsIC.C.

{
  _centers.resize(_x_positions.size() + _npart);

  // First place the specified (large) particles from the input file
  for (unsigned int i = 0; i < _x_positions.size(); ++i)
  {
    _centers[i](0) = _x_positions[i];
    _centers[i](1) = _y_positions[i];
    _centers[i](2) = _z_positions[i];
  }

  // Next place the randomly positioned (small) particles
  for (unsigned int i = _x_positions.size(); i < _x_positions.size() + _npart; ++i)
  {
    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;

      // check for collisions with the specified (large) and randomly placed small particles
      for (unsigned int j = 0; j < i; ++j)
      {
        // Compute the distance r1 from the center of each specified superellipsoid to its
        // outside edge along the vector between the specified superellipsoid and the current
        // randomly positioned one.
        // This uses the equation for a superellipse in polar coordinates and substitutes
        // distances for sin, cos functions.
        Point dist_vec = _mesh.minPeriodicVector(_var.number(), _centers[i], _centers[j]);
        const Real dist = dist_vec.norm();

        // First calculate rmn1 = r1^(-n), replacing sin, cos functions with distances
        Real rmn1 = (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]));
        // Then calculate r1 from rmn1
        const Real r1 = std::pow(rmn1, (-1.0 / _ns[j]));

        // Now calculate the distance r2 from the center of the randomly placed
        // superellipsoid to its outside edge in the same manner
        Real rmn2 = (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]));
        const Real r2 = std::pow(rmn2, (-1.0 / _ns[i]));

        // Calculate the distance between the edges (first in the list are the large then come the
        // small)
        if ((dist - r1 - r2) < (j < _x_positions.size() ? _large_spac : _small_spac))
          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("Too many tries in MultiSmoothCircleIC");

  accept:
    continue;
  }
}

computeSuperellipsoidExponents()

void BimodalSuperellipsoidsIC::computeSuperellipsoidExponents ( )

protectedvirtual

Reimplemented from SpecifiedSmoothSuperellipsoidIC.

Definition at line 137 of file BimodalSuperellipsoidsIC.C.

{
  _ns.resize(_input_ns.size() + _npart);

  // First fill in the specified (large) superellipsoids from the input file
  for (unsigned int i = 0; i < _input_ns.size(); ++i)
    _ns[i] = _input_ns[i];

  // Then fill in the randomly positioned (small) superellipsoids
  // The shape is assumed to stay constant so n does not vary
  for (unsigned int i = _input_ns.size(); i < _input_ns.size() + _npart; ++i)
    _ns[i] = _small_n;
}

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.

Referenced by SmoothSuperellipsoidBaseIC::gradient().

{
  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);
}

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.

Referenced by BimodalInverseSuperellipsoidsIC::value().

{
  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;
}

computeSuperellipsoidSemiaxes()

void BimodalSuperellipsoidsIC::computeSuperellipsoidSemiaxes ( )

protectedvirtual

Reimplemented from SpecifiedSmoothSuperellipsoidIC.

Definition at line 88 of file BimodalSuperellipsoidsIC.C.

{
  _as.resize(_input_as.size() + _npart);
  _bs.resize(_input_bs.size() + _npart);
  _cs.resize(_input_cs.size() + _npart);

  // First fill in the specified (large) superellipsoids from the input file
  for (unsigned int i = 0; i < _input_as.size(); ++i)
  {
    _as[i] = _input_as[i];
    _bs[i] = _input_bs[i];
    _cs[i] = _input_cs[i];
  }

  // Then fill in the randomly positioned (small) superellipsoids
  for (unsigned int i = _input_as.size(); i < _input_as.size() + _npart; ++i)
  {
    // Vary semiaxes
    switch (_size_variation_type)
    {
      case 0: // Random distrubtion, maintaining constant shape
      {
        Real rand_num = _random.rand(_tid);
        _as[i] = _small_a * (1.0 + (1.0 - 2.0 * rand_num) * _size_variation);
        _bs[i] = _small_b * (1.0 + (1.0 - 2.0 * rand_num) * _size_variation);
        _cs[i] = _small_c * (1.0 + (1.0 - 2.0 * rand_num) * _size_variation);
        break;
      }
      case 1: // Normal distribution of semiaxis size, maintaining constant shape
        _as[i] = _random.randNormal(_tid, _small_a, _size_variation);
        _bs[i] = _as[i] * _small_b / _small_a;
        _cs[i] = _as[i] * _small_c / _small_a;
        break;
      case 2: // No variation
        _as[i] = _small_a;
        _bs[i] = _small_b;
        _cs[i] = _small_c;
    }

    if (_as[i] < 0.0)
      _as[i] = 0.0;
    if (_bs[i] < 0.0)
      _bs[i] = 0.0;
    if (_cs[i] < 0.0)
      _cs[i] = 0.0;
  }
}

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.

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

{
  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;
}

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 BimodalSuperellipsoidsIC::initialSetup ( )

virtual

Reimplemented from SmoothSuperellipsoidBaseIC.

Reimplemented in BimodalInverseSuperellipsoidsIC.

Definition at line 70 of file BimodalSuperellipsoidsIC.C.

Referenced by BimodalInverseSuperellipsoidsIC::initialSetup().

{
  // 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;

  if (_size_variation_type == 2 && _size_variation > 0.0)
    mooseError("If size_variation > 0.0, you must pass in a size_variation_type in "
               "BimodalSuperellipsoidsIC");

  SmoothSuperellipsoidBaseIC::initialSetup();
}

value()

Real SmoothSuperellipsoidBaseIC::value ( const Point &  p )

virtualinherited

Reimplemented in BimodalInverseSuperellipsoidsIC.

Definition at line 72 of file SmoothSuperellipsoidBaseIC.C.

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

{
  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;
}

Member Data Documentation

_as

std::vector<Real> SmoothSuperellipsoidBaseIC::_as

protectedinherited

Definition at line 62 of file SmoothSuperellipsoidBaseIC.h.

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

_bottom_left

Point BimodalSuperellipsoidsIC::_bottom_left

protected

Definition at line 56 of file BimodalSuperellipsoidsIC.h.

Referenced by computeSuperellipsoidCenters(), BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters(), and initialSetup().

_bs

std::vector<Real> SmoothSuperellipsoidBaseIC::_bs

protectedinherited

Definition at line 63 of file SmoothSuperellipsoidBaseIC.h.

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

_centers

std::vector<Point> SmoothSuperellipsoidBaseIC::_centers

protectedinherited

Definition at line 61 of file SmoothSuperellipsoidBaseIC.h.

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

_cs

std::vector<Real> SmoothSuperellipsoidBaseIC::_cs

protectedinherited

Definition at line 64 of file SmoothSuperellipsoidBaseIC.h.

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

_input_as

std::vector<Real> SpecifiedSmoothSuperellipsoidIC::_input_as

protectedinherited

Definition at line 39 of file SpecifiedSmoothSuperellipsoidIC.h.

Referenced by SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidSemiaxes(), and computeSuperellipsoidSemiaxes().

_input_bs

std::vector<Real> SpecifiedSmoothSuperellipsoidIC::_input_bs

protectedinherited

Definition at line 40 of file SpecifiedSmoothSuperellipsoidIC.h.

Referenced by SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidSemiaxes(), and computeSuperellipsoidSemiaxes().

_input_cs

std::vector<Real> SpecifiedSmoothSuperellipsoidIC::_input_cs

protectedinherited

Definition at line 41 of file SpecifiedSmoothSuperellipsoidIC.h.

Referenced by SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidSemiaxes(), and computeSuperellipsoidSemiaxes().

_input_ns

std::vector<Real> SpecifiedSmoothSuperellipsoidIC::_input_ns

protectedinherited

Definition at line 42 of file SpecifiedSmoothSuperellipsoidIC.h.

Referenced by SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidExponents(), and computeSuperellipsoidExponents().

_int_width

Real SmoothSuperellipsoidBaseIC::_int_width

protectedinherited

Definition at line 56 of file SmoothSuperellipsoidBaseIC.h.

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

_invalue

Real SmoothSuperellipsoidBaseIC::_invalue

protectedinherited

Definition at line 53 of file SmoothSuperellipsoidBaseIC.h.

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

_large_spac

Real BimodalSuperellipsoidsIC::_large_spac

protected

Definition at line 45 of file BimodalSuperellipsoidsIC.h.

Referenced by computeSuperellipsoidCenters(), and BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters().

_max_num_tries

const unsigned int BimodalSuperellipsoidsIC::_max_num_tries

protected

Definition at line 54 of file BimodalSuperellipsoidsIC.h.

Referenced by computeSuperellipsoidCenters(), and BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters().

_mesh

MooseMesh& SmoothSuperellipsoidBaseIC::_mesh

protectedinherited

Definition at line 51 of file SmoothSuperellipsoidBaseIC.h.

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

_nestedvalue

Real SmoothSuperellipsoidBaseIC::_nestedvalue

protectedinherited

Definition at line 55 of file SmoothSuperellipsoidBaseIC.h.

Referenced by SmoothSuperellipsoidBaseIC::computeSuperellipsoidInverseValue().

_npart

unsigned int BimodalSuperellipsoidsIC::_npart

protected

Variables to describe the randomly placed (smaller) superellipsoids.

Definition at line 43 of file BimodalSuperellipsoidsIC.h.

Referenced by computeSuperellipsoidCenters(), BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters(), computeSuperellipsoidExponents(), computeSuperellipsoidSemiaxes(), and BimodalInverseSuperellipsoidsIC::value().

_ns

std::vector<Real> SmoothSuperellipsoidBaseIC::_ns

protectedinherited

Definition at line 65 of file SmoothSuperellipsoidBaseIC.h.

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

_num_dim

unsigned int SmoothSuperellipsoidBaseIC::_num_dim

protectedinherited

Definition at line 59 of file SmoothSuperellipsoidBaseIC.h.

_outvalue

Real SmoothSuperellipsoidBaseIC::_outvalue

protectedinherited

Definition at line 54 of file SmoothSuperellipsoidBaseIC.h.

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

_random

MooseRandom SmoothSuperellipsoidBaseIC::_random

protectedinherited

Definition at line 67 of file SmoothSuperellipsoidBaseIC.h.

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

_range

Point BimodalSuperellipsoidsIC::_range

protected

Definition at line 58 of file BimodalSuperellipsoidsIC.h.

Referenced by computeSuperellipsoidCenters(), BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters(), and initialSetup().

_size_variation

const Real BimodalSuperellipsoidsIC::_size_variation

protected

Definition at line 50 of file BimodalSuperellipsoidsIC.h.

Referenced by computeSuperellipsoidSemiaxes(), initialSetup(), and BimodalInverseSuperellipsoidsIC::initialSetup().

_size_variation_type

const MooseEnum BimodalSuperellipsoidsIC::_size_variation_type

protected

Definition at line 51 of file BimodalSuperellipsoidsIC.h.

Referenced by computeSuperellipsoidSemiaxes(), initialSetup(), and BimodalInverseSuperellipsoidsIC::initialSetup().

_small_a

Real BimodalSuperellipsoidsIC::_small_a

protected

Definition at line 46 of file BimodalSuperellipsoidsIC.h.

Referenced by computeSuperellipsoidSemiaxes().

_small_b

Real BimodalSuperellipsoidsIC::_small_b

protected

Definition at line 47 of file BimodalSuperellipsoidsIC.h.

Referenced by computeSuperellipsoidSemiaxes().

_small_c

Real BimodalSuperellipsoidsIC::_small_c

protected

Definition at line 48 of file BimodalSuperellipsoidsIC.h.

Referenced by computeSuperellipsoidSemiaxes().

_small_n

Real BimodalSuperellipsoidsIC::_small_n

protected

Definition at line 49 of file BimodalSuperellipsoidsIC.h.

Referenced by computeSuperellipsoidExponents().

_small_spac

Real BimodalSuperellipsoidsIC::_small_spac

protected

Definition at line 44 of file BimodalSuperellipsoidsIC.h.

Referenced by computeSuperellipsoidCenters(), and BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters().

_top_right

Point BimodalSuperellipsoidsIC::_top_right

protected

Definition at line 57 of file BimodalSuperellipsoidsIC.h.

Referenced by initialSetup().

_x_positions

std::vector<Real> SpecifiedSmoothSuperellipsoidIC::_x_positions

protectedinherited

Definition at line 36 of file SpecifiedSmoothSuperellipsoidIC.h.

Referenced by SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidCenters(), computeSuperellipsoidCenters(), BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters(), and BimodalInverseSuperellipsoidsIC::value().

_y_positions

std::vector<Real> SpecifiedSmoothSuperellipsoidIC::_y_positions

protectedinherited

Definition at line 37 of file SpecifiedSmoothSuperellipsoidIC.h.

Referenced by SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidCenters(), computeSuperellipsoidCenters(), and BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters().

_z_positions

std::vector<Real> SpecifiedSmoothSuperellipsoidIC::_z_positions

protectedinherited

Definition at line 38 of file SpecifiedSmoothSuperellipsoidIC.h.

Referenced by SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidCenters(), computeSuperellipsoidCenters(), and BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters().

_zero_gradient

bool SmoothSuperellipsoidBaseIC::_zero_gradient

protectedinherited

Definition at line 57 of file SmoothSuperellipsoidBaseIC.h.

Referenced by SmoothSuperellipsoidBaseIC::gradient().

---

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

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