SmoothSuperellipsoidBaseIC is the base class for all initial conditions that create superellipsoids. More...

#include <SmoothSuperellipsoidBaseIC.h>

Inheritance diagram for SmoothSuperellipsoidBaseIC:

Public Member Functions
	SmoothSuperellipsoidBaseIC (const InputParameters &parameters)

virtual Real	value (const Point &p)

virtual RealGradient	gradient (const Point &p)

virtual void	initialSetup ()

Protected Member Functions
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)

virtual void	computeSuperellipsoidSemiaxes ()=0

virtual void	computeSuperellipsoidExponents ()=0

virtual void	computeSuperellipsoidCenters ()=0

Protected Attributes
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

SmoothSuperellipsoidBaseIC is the base class for all initial conditions that create superellipsoids.

A superellipsoid is described by \( \left|\frac{x}{a}\right|^n + \left|\frac{y}{b}\right|^n + \left|\frac{z}{c}\right|^n = 1\). Note that all children must resize _as, _bs, _cs, _ns, and _centers.

Definition at line 28 of file SmoothSuperellipsoidBaseIC.h.

Constructor & Destructor Documentation

◆ SmoothSuperellipsoidBaseIC()

SmoothSuperellipsoidBaseIC::SmoothSuperellipsoidBaseIC ( const InputParameters & parameters )

Definition at line 37 of file SmoothSuperellipsoidBaseIC.C.

   : InitialCondition(parameters),
     _mesh(_fe_problem.mesh()),
     _invalue(parameters.get<Real>("invalue")),
     _outvalue(parameters.get<Real>("outvalue")),
     _nestedvalue(isParamValid("nestedvalue") ? parameters.get<Real>("nestedvalue")
                                              : parameters.get<Real>("outvalue")),
     _int_width(parameters.get<Real>("int_width")),
     _zero_gradient(parameters.get<bool>("zero_gradient"))
 {
   _random.seed(_tid, getParam<unsigned int>("rand_seed"));
 }

Member Function Documentation

◆ computeSuperellipsoidCenters()

virtual void SmoothSuperellipsoidBaseIC::computeSuperellipsoidCenters ( )

protectedpure virtual

Implemented in BimodalInverseSuperellipsoidsIC, BimodalSuperellipsoidsIC, MultiSmoothSuperellipsoidIC, SmoothSuperellipsoidIC, and SpecifiedSmoothSuperellipsoidIC.

Referenced by initialSetup().

◆ computeSuperellipsoidExponents()

virtual void SmoothSuperellipsoidBaseIC::computeSuperellipsoidExponents ( )

protectedpure virtual

Implemented in BimodalSuperellipsoidsIC, MultiSmoothSuperellipsoidIC, SmoothSuperellipsoidIC, and SpecifiedSmoothSuperellipsoidIC.

Referenced by initialSetup().

◆ computeSuperellipsoidGradient()

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

protected

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 gradient().

◆ computeSuperellipsoidInverseValue()

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

protectedvirtual

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()

virtual void SmoothSuperellipsoidBaseIC::computeSuperellipsoidSemiaxes ( )

protectedpure virtual

Implemented in BimodalSuperellipsoidsIC, MultiSmoothSuperellipsoidIC, SmoothSuperellipsoidIC, and SpecifiedSmoothSuperellipsoidIC.

Referenced by initialSetup().

◆ computeSuperellipsoidValue()

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

protectedvirtual

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 gradient(), value(), and BimodalInverseSuperellipsoidsIC::value().

◆ gradient()

RealGradient SmoothSuperellipsoidBaseIC::gradient ( const Point & p )

virtual

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

virtual

Reimplemented in BimodalInverseSuperellipsoidsIC, BimodalSuperellipsoidsIC, and MultiSmoothSuperellipsoidIC.

Definition at line 51 of file SmoothSuperellipsoidBaseIC.C.

 {
   // Compute centers, semiaxes, exponents, and initialize vector sizes
   computeSuperellipsoidSemiaxes();
   computeSuperellipsoidExponents();
   computeSuperellipsoidCenters();
  
   if (_centers.size() != _as.size())
     mooseError("_center and semiaxis _as vectors are not the same size in the Superellipsoid IC");
   if (_centers.size() != _bs.size())
     mooseError("_center and semiaxis _bs vectors are not the same size in the Superellipsoid IC");
   if (_centers.size() != _cs.size())
     mooseError("_center and semiaxis _cs vectors are not the same size in the Superellipsoid IC");
   if (_centers.size() != _ns.size())
     mooseError("_center and exponent _ns vectors are not the same size in the Superellipsoid IC");
  
   if (_centers.size() < 1)
     mooseError("_centers, _as, _bs, _cs, and _ns were not initialized in the Superellipsoid IC");
 }

Referenced by MultiSmoothSuperellipsoidIC::initialSetup(), and BimodalSuperellipsoidsIC::initialSetup().

◆ value()

Real SmoothSuperellipsoidBaseIC::value ( const Point & p )

virtual

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