AEFVSlopeLimitingOneD Class Reference

One-dimensional slope limiting to get the limited slope of cell average variable for the advection equation using a cell-centered finite volume method. More...

#include <AEFVSlopeLimitingOneD.h>

Inheritance diagram for AEFVSlopeLimitingOneD:

Public Member Functions
	AEFVSlopeLimitingOneD (const InputParameters &parameters)
virtual std::vector< RealGradient >	limitElementSlope () const override
	compute the limited slope of the cell More...
virtual void	initialize ()
virtual void	finalize ()
virtual void	computeElement ()
virtual const std::vector< RealGradient > &	getElementSlope (dof_id_type elementid) const
	accessor function call More...
virtual void	execute ()
virtual void	pre ()
virtual void	preElement (const Elem *elem)
virtual void	onElement (const Elem *elem)
virtual void	onBoundary (const Elem *elem, unsigned int side, BoundaryID bnd_id)
virtual void	onInternalSide (const Elem *elem, unsigned int side)
virtual void	onInterface (const Elem *elem, unsigned int side, BoundaryID bnd_id)
virtual void	post ()
virtual void	subdomainChanged ()
virtual bool	keepGoing ()
virtual void	meshChanged ()
void	join (const ElementLoopUserObject &)

Protected Member Functions
virtual void	serialize (std::string &serialized_buffer)
virtual void	deserialize (std::vector< std::string > &serialized_buffers)
virtual void	caughtMooseException (MooseException &e)
virtual void	computeBoundary ()
virtual void	computeInternalSide ()
virtual void	computeInterface ()

Protected Attributes
MooseVariable *	_u
	the input variable More...
MooseEnum	_scheme
	One-D slope limiting scheme. More...
std::map< dof_id_type, std::vector< RealGradient > > &	_lslope
	store the updated slopes into this map indexed by element ID More...
const bool	_include_bc
	option whether to include BCs More...
const MooseArray< Point > &	_q_point_face
	required data for face assembly More...
const QBase *const &	_qrule_face
const MooseArray< Real > &	_JxW_face
const MooseArray< Point > &	_normals_face
const unsigned int &	_side
	current side of the current element More...
const Elem *const &	_side_elem
const Real &	_side_volume
const Elem *const &	_neighbor_elem
	the neighboring element More...
MooseMesh &	_mesh
const Elem *	_current_elem
const Real &	_current_elem_volume
unsigned int	_current_side
const Elem *	_current_neighbor
const MooseArray< Point > &	_q_point
const QBase *const &	_qrule
const MooseArray< Real > &	_JxW
const MooseArray< Real > &	_coord
bool	_have_interface_elems
	true if we have cached interface elements, false if they need to be cached. We want to (re)cache only when mesh changed More...
std::set< dof_id_type >	_interface_elem_ids
	List of element IDs that are on the processor boundary and need to be send to other processors. More...
SubdomainID	_subdomain
	The subdomain for the current element. More...
SubdomainID	_old_subdomain
	The subdomain for the last element. More...

Static Private Attributes
static Threads::spin_mutex	_mutex

Detailed Description

One-dimensional slope limiting to get the limited slope of cell average variable for the advection equation using a cell-centered finite volume method.

Definition at line 26 of file AEFVSlopeLimitingOneD.h.

Constructor & Destructor Documentation

AEFVSlopeLimitingOneD()

AEFVSlopeLimitingOneD::AEFVSlopeLimitingOneD

(

const InputParameters &

parameters

)

Definition at line 28 of file AEFVSlopeLimitingOneD.C.

  : SlopeLimitingBase(parameters), _u(getVar("u", 0)), _scheme(getParam<MooseEnum>("scheme"))
{
}

Member Function Documentation

caughtMooseException()

void ElementLoopUserObject::caughtMooseException ( MooseException &  e )

protectedvirtualinherited

Definition at line 260 of file ElementLoopUserObject.C.

{
  std::string what(e.what());
  _fe_problem.setException(what);
}

Referenced by ElementLoopUserObject::execute().

computeBoundary()

void ElementLoopUserObject::computeBoundary ( )

protectedvirtualinherited

Definition at line 238 of file ElementLoopUserObject.C.

{
}

Referenced by ElementLoopUserObject::onBoundary().

computeElement()

void SlopeLimitingBase::computeElement ( )

virtualinherited

Reimplemented from ElementLoopUserObject.

Definition at line 70 of file SlopeLimitingBase.C.

{
  dof_id_type _elementID = _current_elem->id();
 
  _lslope[_elementID] = limitElementSlope();
}

computeInterface()

void ElementLoopUserObject::computeInterface ( )

protectedvirtualinherited

Definition at line 248 of file ElementLoopUserObject.C.

{
}

Referenced by ElementLoopUserObject::onInterface().

computeInternalSide()

void ElementLoopUserObject::computeInternalSide ( )

protectedvirtualinherited

Definition at line 243 of file ElementLoopUserObject.C.

{
}

Referenced by ElementLoopUserObject::onInternalSide().

deserialize()

void SlopeLimitingBase::deserialize ( std::vector< std::string > &  serialized_buffers )

protectedvirtualinherited

Definition at line 97 of file SlopeLimitingBase.C.

{
  // The input string stream used for deserialization
  std::istringstream iss;
 
  mooseAssert(serialized_buffers.size() == _app.n_processors(),
              "Unexpected size of serialized_buffers: " << serialized_buffers.size());
 
  for (auto rank = decltype(_app.n_processors())(0); rank < serialized_buffers.size(); ++rank)
  {
    if (rank == processor_id())
      continue;
 
    iss.str(serialized_buffers[rank]); // populate the stream with a new buffer
    iss.clear();                       // reset the string stream state
 
    // Load the communicated data into all of the other processors' slots
 
    unsigned int size = 0;
    iss.read((char *)&size, sizeof(size));
 
    for (unsigned int i = 0; i < size; i++)
    {
      dof_id_type key;
      loadHelper(iss, key, this);
 
      std::vector<RealGradient> value;
      loadHelper(iss, value, this);
 
      // merge the data we received from other procs
      _lslope.insert(std::pair<dof_id_type, std::vector<RealGradient>>(key, value));
    }
  }
}

Referenced by SlopeLimitingBase::finalize().

execute()

void ElementLoopUserObject::execute ( )

virtualinherited

Definition at line 75 of file ElementLoopUserObject.C.

{
  ConstElemRange & elem_range = *_mesh.getActiveLocalElementRange();
 
  try
  {
    pre();
 
    _subdomain = std::numeric_limits<SubdomainID>::max();
    ConstElemRange::const_iterator el = elem_range.begin();
    for (el = elem_range.begin(); el != elem_range.end(); ++el)
    {
      if (!keepGoing())
        break;
 
      const Elem * elem = *el;
      unsigned int cur_subdomain = elem->subdomain_id();
      preElement(elem);
 
      _old_subdomain = _subdomain;
      _subdomain = cur_subdomain;
 
      if (this->hasBlocks(_subdomain))
      {
        if (_subdomain != _old_subdomain)
          subdomainChanged();
 
        onElement(elem);
 
        for (unsigned int side = 0; side < elem->n_sides(); side++)
        {
          std::vector<BoundaryID> boundary_ids = _mesh.getBoundaryIDs(elem, side);
 
          if (boundary_ids.size() > 0)
            for (std::vector<BoundaryID>::iterator it = boundary_ids.begin();
                 it != boundary_ids.end();
                 ++it)
              onBoundary(elem, side, *it);
 
          if (elem->neighbor_ptr(side) != NULL)
          {
            if (this->hasBlocks(elem->neighbor_ptr(side)->subdomain_id()))
              onInternalSide(elem, side);
            if (boundary_ids.size() > 0)
              for (std::vector<BoundaryID>::iterator it = boundary_ids.begin();
                   it != boundary_ids.end();
                   ++it)
                onInterface(elem, side, *it);
          }
        } // sides
      }
    } // range
 
    post();
  }
  catch (MooseException & e)
  {
    caughtMooseException(e);
  }
}

finalize()

void SlopeLimitingBase::finalize ( )

virtualinherited

Reimplemented from ElementLoopUserObject.

Definition at line 133 of file SlopeLimitingBase.C.

{
  ElementLoopUserObject::finalize();
 
  if (_app.n_processors() > 1)
  {
    std::vector<std::string> send_buffers(1);
    std::vector<std::string> recv_buffers;
 
    recv_buffers.reserve(_app.n_processors());
    serialize(send_buffers[0]);
    comm().allgather_packed_range((void *)(nullptr),
                                  send_buffers.begin(),
                                  send_buffers.end(),
                                  std::back_inserter(recv_buffers));
    deserialize(recv_buffers);
  }
}

getElementSlope()

const std::vector< RealGradient > & SlopeLimitingBase::getElementSlope ( dof_id_type  elementid ) const

virtualinherited

accessor function call

Definition at line 58 of file SlopeLimitingBase.C.

{
  Threads::spin_mutex::scoped_lock lock(_mutex);
  std::map<dof_id_type, std::vector<RealGradient>>::const_iterator pos = _lslope.find(elementid);
 
  if (pos == _lslope.end())
    mooseError("Limited slope is not cached for element id '", elementid, "' in ", __FUNCTION__);
 
  return pos->second;
}

Referenced by AEFVMaterial::computeQpProperties().

initialize()

void SlopeLimitingBase::initialize ( )

virtualinherited

Reimplemented from ElementLoopUserObject.

Definition at line 50 of file SlopeLimitingBase.C.

{
  ElementLoopUserObject::initialize();
 
  _lslope.clear();
}

join()

void ElementLoopUserObject::join ( const ElementLoopUserObject &  )

inherited

Definition at line 228 of file ElementLoopUserObject.C.

{
}

keepGoing()

virtual bool ElementLoopUserObject::keepGoing ( )

inlinevirtualinherited

Definition at line 80 of file ElementLoopUserObject.h.

{ return true; }

Referenced by ElementLoopUserObject::execute().

limitElementSlope()

std::vector< RealGradient > AEFVSlopeLimitingOneD::limitElementSlope ( ) const

overridevirtual

compute the limited slope of the cell

Implements SlopeLimitingBase.

Definition at line 34 of file AEFVSlopeLimitingOneD.C.

{
  // you should know how many equations you are solving and assign this number
  // e.g. = 1 (for the advection equation)
  unsigned int nvars = 1;
 
  const Elem * elem = _current_elem;
 
  // index of conserved variable
  unsigned int iv;
 
  // index of sides around an element
  unsigned int is;
 
  // index of the neighbor element
  unsigned int in;
 
  // number of sides surrounding an element = 2 in 1D
  unsigned int nside = elem->n_sides();
 
  // number of reconstruction stencils = 3 in 1D
  unsigned int nsten = nside + 1;
 
  // vector for the gradients of primitive variables
  std::vector<RealGradient> ugrad(nvars, RealGradient(0., 0., 0.));
 
  // array to store center coordinates of this cell and its neighbor cells
  std::vector<Real> xc(nsten, 0.);
 
  // the first always stores the current cell
  xc[0] = elem->centroid()(0);
 
  // array for the cell-average values in the current cell and its neighbors
  std::vector<std::vector<Real>> ucell(nsten, std::vector<Real>(nvars, 0.));
 
  // central slope:
  //                  u_{i+1} - u {i-1}
  //                  -----------------
  //                  x_{i+1} - x_{i-1}
 
  // left-side slope:
  //                  u_{i} - u {i-1}
  //                  ---------------
  //                  x_{i} - x_{i-1}
 
  // right-side slope:
  //                  u_{i+1} - u {i}
  //                  ---------------
  //                  x_{i+1} - x_{i}
 
  // array to store the central and one-sided slopes, where the first should be central slope
  std::vector<std::vector<Real>> sigma(nsten, std::vector<Real>(nvars, 0.));
 
  // get the cell-average variable in the central cell
  if (_is_implicit)
    ucell[0][0] = _u->getElementalValue(elem);
  else
    ucell[0][0] = _u->getElementalValueOld(elem);
 
  // a flag to indicate the boundary side of the current cell
 
  unsigned int bflag = 0;
 
  // loop over the sides to compute the one-sided slopes
 
  for (is = 0; is < nside; is++)
  {
    in = is + 1;
 
    // when the current element is an internal cell
    if (elem->neighbor_ptr(is) != NULL)
    {
      const Elem * neig = elem->neighbor_ptr(is);
      if (this->hasBlocks(neig->subdomain_id()))
      {
        xc[in] = neig->centroid()(0);
 
        // get the cell-average variable in this neighbor cell
        if (_is_implicit)
          ucell[in][0] = _u->getElementalValue(neig);
        else
          ucell[in][0] = _u->getElementalValueOld(neig);
 
        // calculate the one-sided slopes of primitive variables
 
        for (iv = 0; iv < nvars; iv++)
          sigma[in][iv] = (ucell[0][iv] - ucell[in][iv]) / (xc[0] - xc[in]);
      }
      else
        bflag = in;
    }
    // when the current element is at the boundary,
    // we choose not to construct the slope in 1D just for convenience.
    else
    {
      bflag = in;
    }
  }
 
  // calculate the slope of the current element
  // according to the choice of the slope limiter algorithm
 
  switch (_scheme)
  {
    // first-order, zero slope
    case 0:
      break;
 
    // ==============
    // minmod limiter
    // ==============
    case 1:
 
      if (bflag == 0)
      {
        for (iv = 0; iv < nvars; iv++)
        {
          if ((sigma[1][iv] * sigma[2][iv]) > 0.)
          {
            if (std::abs(sigma[1][iv]) < std::abs(sigma[2][iv]))
              ugrad[iv](0) = sigma[1][iv];
            else
              ugrad[iv](0) = sigma[2][iv];
          }
        }
      }
      break;
 
    // ===========================================
    // MC (monotonized central-difference limiter)
    // ===========================================
    case 2:
 
      if (bflag == 0)
      {
        for (iv = 0; iv < nvars; iv++)
          sigma[0][iv] = (ucell[1][iv] - ucell[2][iv]) / (xc[1] - xc[2]);
 
        for (iv = 0; iv < nvars; iv++)
        {
          if (sigma[0][iv] > 0. && sigma[1][iv] > 0. && sigma[2][iv] > 0.)
            ugrad[iv](0) = std::min(sigma[0][iv], 2. * std::min(sigma[1][iv], sigma[2][iv]));
          else if (sigma[0][iv] < 0. && sigma[1][iv] < 0. && sigma[2][iv] < 0.)
            ugrad[iv](0) = std::max(sigma[0][iv], 2. * std::max(sigma[1][iv], sigma[2][iv]));
        }
      }
      break;
 
    // ================
    // Superbee limiter
    // ================
    case 3:
 
      if (bflag == 0)
      {
        for (iv = 0; iv < nvars; iv++)
        {
          Real sigma1 = 0.;
          Real sigma2 = 0.;
 
          // calculate sigma1 with minmod
          if (sigma[2][iv] > 0. && sigma[1][iv] > 0.)
            sigma1 = std::min(sigma[2][iv], 2. * sigma[1][iv]);
          else if (sigma[2][iv] < 0. && sigma[1][iv] < 0.)
            sigma1 = std::max(sigma[2][iv], 2. * sigma[1][iv]);
 
          // calculate sigma2 with minmod
          if (sigma[2][iv] > 0. && sigma[1][iv] > 0.)
            sigma2 = std::min(2. * sigma[2][iv], sigma[1][iv]);
          else if (sigma[2][iv] < 0. && sigma[1][iv] < 0.)
            sigma2 = std::max(2. * sigma[2][iv], sigma[1][iv]);
 
          // calculate sigma with maxmod
          if (sigma1 > 0. && sigma2 > 0.)
            ugrad[iv](0) = std::max(sigma1, sigma2);
          else if (sigma1 < 0. && sigma2 < 0.)
            ugrad[iv](0) = std::min(sigma1, sigma2);
        }
      }
      break;
 
    default:
      mooseError("Unknown 1D TVD-type slope limiter scheme");
      break;
  }
 
  return ugrad;
}

meshChanged()

void ElementLoopUserObject::meshChanged ( )

virtualinherited

Reimplemented in SlopeReconstructionBase.

Definition at line 253 of file ElementLoopUserObject.C.

{
  _interface_elem_ids.clear();
  _have_interface_elems = false;
}

Referenced by SlopeReconstructionBase::meshChanged().

onBoundary()

void ElementLoopUserObject::onBoundary ( const Elem *  elem, unsigned int  side, BoundaryID  bnd_id  )

virtualinherited

Definition at line 160 of file ElementLoopUserObject.C.

{
  _current_side = side;
  computeBoundary();
}

Referenced by ElementLoopUserObject::execute().

onElement()

void ElementLoopUserObject::onElement ( const Elem *  elem )

virtualinherited

Definition at line 153 of file ElementLoopUserObject.C.

{
  _current_elem = elem;
  computeElement();
}

Referenced by ElementLoopUserObject::execute().

onInterface()

void ElementLoopUserObject::onInterface ( const Elem *  elem, unsigned int  side, BoundaryID  bnd_id  )

virtualinherited

Definition at line 195 of file ElementLoopUserObject.C.

{
  _current_elem = elem;
  // Pointer to the neighbor we are currently working on.
  _current_neighbor = elem->neighbor_ptr(side);
 
  // Get the global id of the element and the neighbor
  const dof_id_type elem_id = elem->id();
  const dof_id_type neighbor_id = _current_neighbor->id();
 
  // TODO: add if-statement to check if this needs to be executed
  if ((_current_neighbor->active() && (_current_neighbor->level() == elem->level()) &&
       (elem_id < neighbor_id)) ||
      (_current_neighbor->level() < elem->level()))
  {
    computeInterface();
  }
 
  if (!_have_interface_elems &&
      (_current_elem->processor_id() != _current_neighbor->processor_id()))
  {
    // if my current neighbor is on another processor store the current element
    // ID for later communication
    _interface_elem_ids.insert(_current_elem->id());
  }
}

Referenced by ElementLoopUserObject::execute().

onInternalSide()

void ElementLoopUserObject::onInternalSide ( const Elem *  elem, unsigned int  side  )

virtualinherited

Definition at line 167 of file ElementLoopUserObject.C.

{
  _current_elem = elem;
  // Pointer to the neighbor we are currently working on.
  _current_neighbor = elem->neighbor_ptr(side);
 
  // Get the global id of the element and the neighbor
  const dof_id_type elem_id = elem->id();
  const dof_id_type neighbor_id = _current_neighbor->id();
 
  // TODO: add if-statement to check if this needs to be executed
  if ((_current_neighbor->active() && (_current_neighbor->level() == elem->level()) &&
       (elem_id < neighbor_id)) ||
      (_current_neighbor->level() < elem->level()))
  {
    computeInternalSide();
  }
 
  if (!_have_interface_elems &&
      (_current_elem->processor_id() != _current_neighbor->processor_id()))
  {
    // if my current neighbor is on another processor store the current element ID for later
    // communication
    _interface_elem_ids.insert(_current_elem->id());
  }
}

Referenced by ElementLoopUserObject::execute().

post()

void ElementLoopUserObject::post ( )

virtualinherited

Definition at line 223 of file ElementLoopUserObject.C.

{
}

Referenced by ElementLoopUserObject::execute().

pre()

void ElementLoopUserObject::pre ( )

virtualinherited

Definition at line 143 of file ElementLoopUserObject.C.

{
}

Referenced by ElementLoopUserObject::execute().

preElement()

void ElementLoopUserObject::preElement ( const Elem *  elem )

virtualinherited

Definition at line 69 of file ElementLoopUserObject.C.

{
  _fe_problem.setCurrentSubdomainID(elem, _tid);
}

Referenced by ElementLoopUserObject::execute().

serialize()

void SlopeLimitingBase::serialize ( std::string &  serialized_buffer )

protectedvirtualinherited

Definition at line 78 of file SlopeLimitingBase.C.

{
  std::ostringstream oss;
 
  // First store the number of elements to send
  unsigned int size = _interface_elem_ids.size();
  oss.write((char *)&size, sizeof(size));
 
  for (auto it = _interface_elem_ids.begin(); it != _interface_elem_ids.end(); ++it)
  {
    storeHelper(oss, *it, this);
    storeHelper(oss, _lslope[*it], this);
  }
 
  // Populate the passed in string pointer with the string stream's buffer contents
  serialized_buffer.assign(oss.str());
}

Referenced by SlopeLimitingBase::finalize().

subdomainChanged()

void ElementLoopUserObject::subdomainChanged ( )

virtualinherited

Definition at line 148 of file ElementLoopUserObject.C.

{
}

Referenced by ElementLoopUserObject::execute().

Member Data Documentation

_coord

const MooseArray<Real>& ElementLoopUserObject::_coord

protectedinherited

Definition at line 99 of file ElementLoopUserObject.h.

_current_elem

const Elem* ElementLoopUserObject::_current_elem

protectedinherited

Definition at line 91 of file ElementLoopUserObject.h.

Referenced by SlopeLimitingBase::computeElement(), limitElementSlope(), ElementLoopUserObject::onElement(), ElementLoopUserObject::onInterface(), and ElementLoopUserObject::onInternalSide().

_current_elem_volume

const Real& ElementLoopUserObject::_current_elem_volume

protectedinherited

Definition at line 92 of file ElementLoopUserObject.h.

_current_neighbor

const Elem* ElementLoopUserObject::_current_neighbor

protectedinherited

Definition at line 94 of file ElementLoopUserObject.h.

Referenced by ElementLoopUserObject::onInterface(), and ElementLoopUserObject::onInternalSide().

_current_side

unsigned int ElementLoopUserObject::_current_side

protectedinherited

Definition at line 93 of file ElementLoopUserObject.h.

Referenced by ElementLoopUserObject::onBoundary().

_have_interface_elems

bool ElementLoopUserObject::_have_interface_elems

protectedinherited

true if we have cached interface elements, false if they need to be cached. We want to (re)cache only when mesh changed

Definition at line 102 of file ElementLoopUserObject.h.

Referenced by ElementLoopUserObject::finalize(), ElementLoopUserObject::meshChanged(), ElementLoopUserObject::onInterface(), and ElementLoopUserObject::onInternalSide().

_include_bc

const bool SlopeLimitingBase::_include_bc

protectedinherited

option whether to include BCs

Definition at line 48 of file SlopeLimitingBase.h.

_interface_elem_ids

std::set<dof_id_type> ElementLoopUserObject::_interface_elem_ids

protectedinherited

List of element IDs that are on the processor boundary and need to be send to other processors.

Definition at line 104 of file ElementLoopUserObject.h.

Referenced by ElementLoopUserObject::meshChanged(), ElementLoopUserObject::onInterface(), ElementLoopUserObject::onInternalSide(), SlopeLimitingBase::serialize(), and SlopeReconstructionBase::serialize().

_JxW

const MooseArray<Real>& ElementLoopUserObject::_JxW

protectedinherited

Definition at line 98 of file ElementLoopUserObject.h.

_JxW_face

const MooseArray<Real>& SlopeLimitingBase::_JxW_face

protectedinherited

Definition at line 53 of file SlopeLimitingBase.h.

_lslope

std::map<dof_id_type, std::vector<RealGradient> >& SlopeLimitingBase::_lslope

protectedinherited

store the updated slopes into this map indexed by element ID

Definition at line 45 of file SlopeLimitingBase.h.

Referenced by SlopeLimitingBase::computeElement(), SlopeLimitingBase::deserialize(), SlopeLimitingBase::getElementSlope(), SlopeLimitingBase::initialize(), and SlopeLimitingBase::serialize().

_mesh

MooseMesh& ElementLoopUserObject::_mesh

protectedinherited

Definition at line 89 of file ElementLoopUserObject.h.

Referenced by ElementLoopUserObject::execute(), and SlopeReconstructionMultiD::SlopeReconstructionMultiD().

_mutex

Threads::spin_mutex SlopeLimitingBase::_mutex

staticprivateinherited

Definition at line 66 of file SlopeLimitingBase.h.

Referenced by SlopeLimitingBase::getElementSlope().

_neighbor_elem

const Elem* const & SlopeLimitingBase::_neighbor_elem

protectedinherited

the neighboring element

Definition at line 63 of file SlopeLimitingBase.h.

_normals_face

const MooseArray<Point>& SlopeLimitingBase::_normals_face

protectedinherited

Definition at line 54 of file SlopeLimitingBase.h.

_old_subdomain

SubdomainID ElementLoopUserObject::_old_subdomain

protectedinherited

The subdomain for the last element.

Definition at line 110 of file ElementLoopUserObject.h.

Referenced by ElementLoopUserObject::execute().

_q_point

const MooseArray<Point>& ElementLoopUserObject::_q_point

protectedinherited

Definition at line 96 of file ElementLoopUserObject.h.

_q_point_face

const MooseArray<Point>& SlopeLimitingBase::_q_point_face

protectedinherited

required data for face assembly

Definition at line 51 of file SlopeLimitingBase.h.

_qrule

const QBase* const & ElementLoopUserObject::_qrule

protectedinherited

Definition at line 97 of file ElementLoopUserObject.h.

_qrule_face

const QBase* const & SlopeLimitingBase::_qrule_face

protectedinherited

Definition at line 52 of file SlopeLimitingBase.h.

_scheme

MooseEnum AEFVSlopeLimitingOneD::_scheme

protected

One-D slope limiting scheme.

Definition at line 39 of file AEFVSlopeLimitingOneD.h.

Referenced by limitElementSlope().

_side

const unsigned int& SlopeLimitingBase::_side

protectedinherited

current side of the current element

Definition at line 57 of file SlopeLimitingBase.h.

_side_elem

const Elem* const & SlopeLimitingBase::_side_elem

protectedinherited

Definition at line 59 of file SlopeLimitingBase.h.

_side_volume

const Real& SlopeLimitingBase::_side_volume

protectedinherited

Definition at line 60 of file SlopeLimitingBase.h.

_subdomain

SubdomainID ElementLoopUserObject::_subdomain

protectedinherited

The subdomain for the current element.

Definition at line 107 of file ElementLoopUserObject.h.

Referenced by ElementLoopUserObject::execute().

_u

MooseVariable* AEFVSlopeLimitingOneD::_u

protected

the input variable

Definition at line 36 of file AEFVSlopeLimitingOneD.h.

Referenced by limitElementSlope().

---

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

• rdg/include/userobjects/AEFVSlopeLimitingOneD.h
• rdg/src/userobjects/AEFVSlopeLimitingOneD.C