SmoothSuperellipsoidIC creates a Superellipsoid of given semiaxes a,b,c and exponent n centered at a given point in the domain. More...

#include <SmoothSuperellipsoidIC.h>

Inheritance diagram for SmoothSuperellipsoidIC:

[legend]

Public Member Functions
	SmoothSuperellipsoidIC (const InputParameters &parameters)

virtual Real	value (const Point &p)

virtual RealGradient	gradient (const Point &p)

virtual void	initialSetup ()

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 Real	_x1

const Real	_y1

const Real	_z1

const Real	_a

const Real	_b

const Real	_c

const Real	_n

const Point	_center

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

SmoothSuperellipsoidIC creates a Superellipsoid of given semiaxes a,b,c and exponent n centered at a given point in the domain.

If int_width > zero, the border of the Superellipsoid with smoothly transition from the invalue to the outvalue.

Definition at line 26 of file SmoothSuperellipsoidIC.h.

Constructor & Destructor Documentation

◆ SmoothSuperellipsoidIC()

SmoothSuperellipsoidIC::SmoothSuperellipsoidIC ( const InputParameters & parameters )

Definition at line 30 of file SmoothSuperellipsoidIC.C.

   : SmoothSuperellipsoidBaseIC(parameters),
     _x1(parameters.get<Real>("x1")),
     _y1(parameters.get<Real>("y1")),
     _z1(parameters.get<Real>("z1")),
     _a(parameters.get<Real>("a")),
     _b(parameters.get<Real>("b")),
     _c(parameters.get<Real>("c")),
     _n(parameters.get<Real>("n")),
     _center(_x1, _y1, _z1)
 {
 }

Member Function Documentation

◆ computeSuperellipsoidCenters()

void SmoothSuperellipsoidIC::computeSuperellipsoidCenters ( )

protectedvirtual

Implements SmoothSuperellipsoidBaseIC.

Definition at line 44 of file SmoothSuperellipsoidIC.C.

 {
   _centers = {_center};
 }

◆ computeSuperellipsoidExponents()

void SmoothSuperellipsoidIC::computeSuperellipsoidExponents ( )

protectedvirtual

Implements SmoothSuperellipsoidBaseIC.

Definition at line 58 of file SmoothSuperellipsoidIC.C.

 {
   _ns = {_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.

 {
   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 SmoothSuperellipsoidIC::computeSuperellipsoidSemiaxes ( )

protectedvirtual

Implements SmoothSuperellipsoidBaseIC.

Definition at line 50 of file SmoothSuperellipsoidIC.C.

 {
   _as = {_a};
   _bs = {_b};
   _cs = {_c};
 }

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

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

virtualinherited

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 )

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