SpecifiedSmoothSuperellipsoidIC creates multiple SmoothSuperellipsoids (number = size of x_positions) that are positioned in the set locations with the set semiaxes a, b, c and exponents n. More...

#include <SpecifiedSmoothSuperellipsoidIC.h>

Inheritance diagram for SpecifiedSmoothSuperellipsoidIC:

[legend]

Public Member Functions
	SpecifiedSmoothSuperellipsoidIC (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
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

Detailed Description

SpecifiedSmoothSuperellipsoidIC creates multiple SmoothSuperellipsoids (number = size of x_positions) that are positioned in the set locations with the set semiaxes a, b, c and exponents n.

Definition at line 25 of file SpecifiedSmoothSuperellipsoidIC.h.

Constructor & Destructor Documentation

◆ SpecifiedSmoothSuperellipsoidIC()

SpecifiedSmoothSuperellipsoidIC::SpecifiedSmoothSuperellipsoidIC ( const InputParameters & parameters )

Definition at line 36 of file SpecifiedSmoothSuperellipsoidIC.C.

   : SmoothSuperellipsoidBaseIC(parameters),
     _x_positions(getParam<std::vector<Real>>("x_positions")),
     _y_positions(getParam<std::vector<Real>>("y_positions")),
     _z_positions(getParam<std::vector<Real>>("z_positions")),
     _input_as(getParam<std::vector<Real>>("as")),
     _input_bs(getParam<std::vector<Real>>("bs")),
     _input_cs(getParam<std::vector<Real>>("cs")),
     _input_ns(getParam<std::vector<Real>>("ns"))
 {
 }

Member Function Documentation

◆ computeSuperellipsoidCenters()

void SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidCenters ( )

protectedvirtual

Implements SmoothSuperellipsoidBaseIC.

Reimplemented in BimodalInverseSuperellipsoidsIC, and BimodalSuperellipsoidsIC.

Definition at line 49 of file SpecifiedSmoothSuperellipsoidIC.C.

 {
   _centers.resize(_x_positions.size());
  
   for (unsigned int circ = 0; circ < _x_positions.size(); ++circ)
   {
     _centers[circ](0) = _x_positions[circ];
     _centers[circ](1) = _y_positions[circ];
     _centers[circ](2) = _z_positions[circ];
   }
 }

◆ computeSuperellipsoidExponents()

void SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidExponents ( )

protectedvirtual

Implements SmoothSuperellipsoidBaseIC.

Reimplemented in BimodalSuperellipsoidsIC.

Definition at line 77 of file SpecifiedSmoothSuperellipsoidIC.C.

 {
   _ns.resize(_input_ns.size());
  
   for (unsigned int circ = 0; circ < _input_ns.size(); ++circ)
     _ns[circ] = _input_ns[circ];
 }

◆ 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 SpecifiedSmoothSuperellipsoidIC::computeSuperellipsoidSemiaxes ( )

protectedvirtual

Implements SmoothSuperellipsoidBaseIC.

Reimplemented in BimodalSuperellipsoidsIC.

Definition at line 62 of file SpecifiedSmoothSuperellipsoidIC.C.

 {
   _as.resize(_input_as.size());
   _bs.resize(_input_bs.size());
   _cs.resize(_input_cs.size());
  
   for (unsigned int circ = 0; circ < _input_as.size(); ++circ)
   {
     _as[circ] = _input_as[circ];
     _bs[circ] = _input_bs[circ];
     _cs[circ] = _input_cs[circ];
   }
 }

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