www.mooseframework.org
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
CNSFVSlopeLimitingOneD Class Reference

A use object that serves as base class for slope limiting to get the limited slopes of cell average variables in 1-D. More...

#include <CNSFVSlopeLimitingOneD.h>

Inheritance diagram for CNSFVSlopeLimitingOneD:
[legend]

Public Member Functions

 CNSFVSlopeLimitingOneD (const InputParameters &parameters)
 
virtual std::vector< RealGradient > limitElementSlope () const
 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 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 * _rho
 the input density More...
 
MooseVariable * _rhou
 the input x-momentum More...
 
MooseVariable * _rhoe
 the input total energy More...
 
const SinglePhaseFluidProperties_fp
 fluid properties user object 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...
 
bool _include_bc
 option whether to include BCs More...
 
const SlopeReconstructionBase_rslope
 slope reconstruction user object More...
 
const MooseArray< Point > & _q_point_face
 required data for face assembly More...
 
QBase *& _qrule_face
 
const MooseArray< Real > & _JxW_face
 
const MooseArray< Point > & _normals_face
 
unsigned int & _side
 current side of the current element More...
 
const Elem *& _side_elem
 
const Real & _side_volume
 
const Elem *& _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
 
QBase *& _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...
 

Detailed Description

A use object that serves as base class for slope limiting to get the limited slopes of cell average variables in 1-D.

Definition at line 24 of file CNSFVSlopeLimitingOneD.h.

Constructor & Destructor Documentation

CNSFVSlopeLimitingOneD::CNSFVSlopeLimitingOneD ( const InputParameters &  parameters)

Definition at line 35 of file CNSFVSlopeLimitingOneD.C.

36  : SlopeLimitingBase(parameters),
37  _rho(getVar("rho", 0)),
38  _rhou(getVar("rhou", 0)),
39  _rhoe(getVar("rhoe", 0)),
40  _fp(getUserObject<SinglePhaseFluidProperties>("fluid_properties")),
41  _scheme(getParam<MooseEnum>("scheme"))
42 {
43 }
const SinglePhaseFluidProperties & _fp
fluid properties user object
MooseEnum _scheme
One-D slope limiting scheme.
MooseVariable * _rho
the input density
MooseVariable * _rhou
the input x-momentum
SlopeLimitingBase(const InputParameters &parameters)
MooseVariable * _rhoe
the input total energy

Member Function Documentation

void ElementLoopUserObject::caughtMooseException ( MooseException &  e)
protectedvirtualinherited

Definition at line 253 of file ElementLoopUserObject.C.

Referenced by ElementLoopUserObject::execute().

254 {
255  std::string what(e.what());
256  _fe_problem.setException(what);
257 }
void ElementLoopUserObject::computeBoundary ( )
protectedvirtualinherited

Definition at line 231 of file ElementLoopUserObject.C.

Referenced by ElementLoopUserObject::onBoundary().

232 {
233 }
void SlopeLimitingBase::computeElement ( )
virtualinherited

Reimplemented from ElementLoopUserObject.

Definition at line 68 of file SlopeLimitingBase.C.

69 {
70  dof_id_type _elementID = _current_elem->id();
71 
72  _lslope[_elementID] = limitElementSlope();
73 }
virtual std::vector< RealGradient > limitElementSlope() const =0
compute the slope of the cell
std::map< dof_id_type, std::vector< RealGradient > > _lslope
store the updated slopes into this map indexed by element ID
void ElementLoopUserObject::computeInterface ( )
protectedvirtualinherited

Definition at line 241 of file ElementLoopUserObject.C.

Referenced by ElementLoopUserObject::onInterface().

242 {
243 }
void ElementLoopUserObject::computeInternalSide ( )
protectedvirtualinherited

Definition at line 236 of file ElementLoopUserObject.C.

Referenced by ElementLoopUserObject::onInternalSide().

237 {
238 }
void SlopeLimitingBase::deserialize ( std::vector< std::string > &  serialized_buffers)
protectedvirtualinherited

Definition at line 95 of file SlopeLimitingBase.C.

Referenced by SlopeLimitingBase::finalize().

96 {
97  // The input string stream used for deserialization
98  std::istringstream iss;
99 
100  mooseAssert(serialized_buffers.size() == _app.n_processors(),
101  "Unexpected size of serialized_buffers: " << serialized_buffers.size());
102 
103  for (auto rank = decltype(_app.n_processors())(0); rank < serialized_buffers.size(); ++rank)
104  {
105  if (rank == processor_id())
106  continue;
107 
108  iss.str(serialized_buffers[rank]); // populate the stream with a new buffer
109  iss.clear(); // reset the string stream state
110 
111  // Load the communicated data into all of the other processors' slots
112 
113  unsigned int size = 0;
114  iss.read((char *)&size, sizeof(size));
115 
116  for (unsigned int i = 0; i < size; i++)
117  {
118  dof_id_type key;
119  loadHelper(iss, key, this);
120 
121  std::vector<RealGradient> value;
122  loadHelper(iss, value, this);
123 
124  // merge the data we received from other procs
125  _lslope.insert(std::pair<dof_id_type, std::vector<RealGradient>>(key, value));
126  }
127  }
128 }
std::map< dof_id_type, std::vector< RealGradient > > _lslope
store the updated slopes into this map indexed by element ID
void ElementLoopUserObject::execute ( )
virtualinherited

Definition at line 69 of file ElementLoopUserObject.C.

70 {
71  ConstElemRange & elem_range = *_mesh.getActiveLocalElementRange();
72 
73  try
74  {
75  pre();
76 
77  _subdomain = std::numeric_limits<SubdomainID>::max();
78  ConstElemRange::const_iterator el = elem_range.begin();
79  for (el = elem_range.begin(); el != elem_range.end(); ++el)
80  {
81  if (!keepGoing())
82  break;
83 
84  const Elem * elem = *el;
85  unsigned int cur_subdomain = elem->subdomain_id();
86 
88  _subdomain = cur_subdomain;
89 
90  if (this->hasBlocks(_subdomain))
91  {
94 
95  onElement(elem);
96 
97  for (unsigned int side = 0; side < elem->n_sides(); side++)
98  {
99  std::vector<BoundaryID> boundary_ids = _mesh.getBoundaryIDs(elem, side);
100 
101  if (boundary_ids.size() > 0)
102  for (std::vector<BoundaryID>::iterator it = boundary_ids.begin();
103  it != boundary_ids.end();
104  ++it)
105  onBoundary(elem, side, *it);
106 
107  if (elem->neighbor(side) != NULL)
108  {
109  if (this->hasBlocks(elem->neighbor(side)->subdomain_id()))
110  onInternalSide(elem, side);
111  if (boundary_ids.size() > 0)
112  for (std::vector<BoundaryID>::iterator it = boundary_ids.begin();
113  it != boundary_ids.end();
114  ++it)
115  onInterface(elem, side, *it);
116  }
117  } // sides
118  }
119  } // range
120 
121  post();
122  }
123  catch (MooseException & e)
124  {
126  }
127 }
virtual void onInterface(const Elem *elem, unsigned int side, BoundaryID bnd_id)
virtual void onInternalSide(const Elem *elem, unsigned int side)
virtual void caughtMooseException(MooseException &e)
virtual void onBoundary(const Elem *elem, unsigned int side, BoundaryID bnd_id)
SubdomainID _subdomain
The subdomain for the current element.
virtual void onElement(const Elem *elem)
SubdomainID _old_subdomain
The subdomain for the last element.
void SlopeLimitingBase::finalize ( )
virtualinherited

Reimplemented from ElementLoopUserObject.

Definition at line 131 of file SlopeLimitingBase.C.

132 {
134 
135  if (_app.n_processors() > 1)
136  {
137  std::vector<std::string> send_buffers(1);
138  std::vector<std::string> recv_buffers;
139 
140  recv_buffers.reserve(_app.n_processors());
141  serialize(send_buffers[0]);
142  comm().allgather_packed_range((void *)(nullptr),
143  send_buffers.begin(),
144  send_buffers.end(),
145  std::back_inserter(recv_buffers));
146  deserialize(recv_buffers);
147  }
148 }
virtual void serialize(std::string &serialized_buffer)
virtual void deserialize(std::vector< std::string > &serialized_buffers)
const std::vector< RealGradient > & SlopeLimitingBase::getElementSlope ( dof_id_type  elementid) const
virtualinherited

accessor function call

Definition at line 56 of file SlopeLimitingBase.C.

Referenced by CNSFVMaterial::computeQpProperties(), and AEFVMaterial::computeQpProperties().

57 {
58  Threads::spin_mutex::scoped_lock lock(_mutex);
59  std::map<dof_id_type, std::vector<RealGradient>>::const_iterator pos = _lslope.find(elementid);
60 
61  if (pos == _lslope.end())
62  mooseError("Limited slope is not cached for element id '", elementid, "' in ", __FUNCTION__);
63 
64  return pos->second;
65 }
static Threads::spin_mutex _mutex
std::map< dof_id_type, std::vector< RealGradient > > _lslope
store the updated slopes into this map indexed by element ID
void SlopeLimitingBase::initialize ( )
virtualinherited

Reimplemented from ElementLoopUserObject.

Definition at line 48 of file SlopeLimitingBase.C.

49 {
51 
52  _lslope.clear();
53 }
std::map< dof_id_type, std::vector< RealGradient > > _lslope
store the updated slopes into this map indexed by element ID
void ElementLoopUserObject::join ( const ElementLoopUserObject )
inherited

Definition at line 221 of file ElementLoopUserObject.C.

222 {
223 }
virtual bool ElementLoopUserObject::keepGoing ( )
inlinevirtualinherited

Definition at line 81 of file ElementLoopUserObject.h.

Referenced by ElementLoopUserObject::execute().

81 { return true; }
std::vector< RealGradient > CNSFVSlopeLimitingOneD::limitElementSlope ( ) const
virtual

compute the limited slope of the cell

index of conserved variable

index of sides around an element

index of the neighbor element

number of sides surrounding an element = 2 in 1D

number of reconstruction stencils = 3 in 1D

number of conserved variables = 3 in 1D

vector for the gradients of primitive variables

array to store center coordinates of this cell and its neighbor cells

the first always stores the current cell

array for the cell-average values in the current cell and its neighbors

array to store the central and one-sided slopes where the first should be central slope

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}

get the cell-average conserved variables in the central cell iv = 0: rho iv = 1: rhou iv = 2: rhoe

convert into primitive variables iv = 0: pres iv = 1: uadv iv = 2: temp

a flag to indicate the boundary side of the current cell

loop over the sides to compute the one-sided slopes

when the current element is an internal cell

get the cell-average conserved variables in this neighbor cell iv = 0: rho iv = 1: rhou iv = 2: rhoe

convert into primitive variables iv = 0: pres iv = 1: uadv iv = 2: temp

calculate the one-sided slopes of primitive variables

When the current element is a boundary cell, in general we do not construct the slope for 1D, and the solution accuracy will not be impaired globally. But we should definitely do it for multi-D. Otherwise the accuracy of system reduces to first-order.

calculate the slope of the current element according to the choice of the slope limiter algorithm

first-order, zero slope

minmod limiter

MC (monotonized central-difference limiter)

Superbee limiter

calculate sigma1 with minmod

calculate sigma2 with minmod

calculate sigma with maxmod

Implements SlopeLimitingBase.

Definition at line 46 of file CNSFVSlopeLimitingOneD.C.

47 {
48  const Elem * elem = _current_elem;
49 
51  unsigned int iv;
52 
54  unsigned int is;
55 
57  unsigned int in;
58 
60  unsigned int nside = elem->n_sides();
61 
63  unsigned int nsten = nside + 1;
64 
66  unsigned int nvars = 5;
67 
69  std::vector<RealGradient> ugrad(nvars, RealGradient(0.0, 0.0, 0.0));
70 
72  std::vector<Real> xc(nsten, 0.);
73 
75  xc[0] = elem->centroid()(0);
76 
78  std::vector<std::vector<Real>> ucell(nsten, std::vector<Real>(nvars, 0.0));
79 
82 
87 
92 
97 
98  std::vector<std::vector<Real>> sigma(nsten, std::vector<Real>(nvars, 0.0));
99 
104 
105  Real rho = _rho->getElementalValue(elem);
106  Real rhou = _rhou->getElementalValue(elem);
107  Real rhoe = _rhoe->getElementalValue(elem);
108 
113 
114  ucell[0][1] = rhou / rho;
115 
116  Real v = 1. / rho;
117  Real e = rhoe / rho - 0.5 * ucell[0][1] * ucell[0][1];
118 
119  ucell[0][0] = _fp.pressure(v, e);
120  ucell[0][4] = _fp.temperature(v, e);
121 
123 
124  unsigned int bflag = 0;
125 
127 
128  for (is = 0; is < nside; is++)
129  {
130  in = is + 1;
131 
133  if (elem->neighbor(is) != NULL)
134  {
135  const Elem * neig = elem->neighbor(is);
136 
137  xc[in] = neig->centroid()(0);
138 
143 
144  rho = _rho->getElementalValue(neig);
145  rhou = _rhou->getElementalValue(neig);
146  rhoe = _rhoe->getElementalValue(neig);
147 
152 
153  ucell[in][1] = rhou / rho;
154 
155  v = 1. / rho;
156  e = rhoe / rho - 0.5 * ucell[in][1] * ucell[in][1];
157 
158  ucell[in][0] = _fp.pressure(v, e);
159  ucell[in][4] = _fp.temperature(v, e);
160 
162 
163  for (iv = 0; iv < nvars; iv++)
164  sigma[in][iv] = (ucell[0][iv] - ucell[in][iv]) / (xc[0] - xc[in]);
165  }
171  else
172  {
173  bflag = in;
174  }
175  }
176 
179 
180  switch (_scheme)
181  {
183  case 0:
184  break;
185 
187  case 1:
188 
189  if (bflag == 0)
190  {
191  for (iv = 0; iv < nvars; iv++)
192  {
193  if ((sigma[1][iv] * sigma[2][iv]) > 0.)
194  {
195  if (std::abs(sigma[1][iv]) < std::abs(sigma[2][iv]))
196  ugrad[iv](0) = sigma[1][iv];
197  else
198  ugrad[iv](0) = sigma[2][iv];
199  }
200  }
201  }
202  break;
203 
205  case 2:
206 
207  if (bflag == 0)
208  {
209  for (iv = 0; iv < nvars; iv++)
210  sigma[0][iv] = (ucell[1][iv] - ucell[2][iv]) / (xc[1] - xc[2]);
211 
212  for (iv = 0; iv < nvars; iv++)
213  {
214  if (sigma[0][iv] > 0. && sigma[1][iv] > 0. && sigma[2][iv] > 0.)
215  ugrad[iv](0) = std::min(sigma[0][iv], 2. * std::min(sigma[1][iv], sigma[2][iv]));
216  else if (sigma[0][iv] < 0. && sigma[1][iv] < 0. && sigma[2][iv] < 0.)
217  ugrad[iv](0) = std::max(sigma[0][iv], 2. * std::max(sigma[1][iv], sigma[2][iv]));
218  }
219  }
220  break;
221 
223  case 3:
224 
225  if (bflag == 0)
226  {
227  for (iv = 0; iv < nvars; iv++)
228  {
229  Real sigma1 = 0.;
230  Real sigma2 = 0.;
231 
233  if (sigma[2][iv] > 0. && sigma[1][iv] > 0.)
234  sigma1 = std::min(sigma[2][iv], 2. * sigma[1][iv]);
235  else if (sigma[2][iv] < 0. && sigma[1][iv] < 0.)
236  sigma1 = std::max(sigma[2][iv], 2. * sigma[1][iv]);
237 
239  if (sigma[2][iv] > 0. && sigma[1][iv] > 0.)
240  sigma2 = std::min(2. * sigma[2][iv], sigma[1][iv]);
241  else if (sigma[2][iv] < 0. && sigma[1][iv] < 0.)
242  sigma2 = std::max(2. * sigma[2][iv], sigma[1][iv]);
243 
245  if (sigma1 > 0. && sigma2 > 0.)
246  ugrad[iv](0) = std::max(sigma1, sigma2);
247  else if (sigma1 < 0. && sigma2 < 0.)
248  ugrad[iv](0) = std::min(sigma1, sigma2);
249  }
250  }
251  break;
252 
253  default:
254  mooseError("Unknown 1D TVD slope limiter scheme");
255  break;
256  }
257 
258  return ugrad;
259 }
const SinglePhaseFluidProperties & _fp
fluid properties user object
MooseEnum _scheme
One-D slope limiting scheme.
virtual Real temperature(Real v, Real u) const =0
Temperature as a function of specific internal energy and specific volume.
MooseVariable * _rho
the input density
MooseVariable * _rhou
the input x-momentum
MooseVariable * _rhoe
the input total energy
virtual Real pressure(Real v, Real u) const =0
Pressure as a function of specific internal energy and specific volume.
void ElementLoopUserObject::meshChanged ( )
virtualinherited

Reimplemented in SlopeReconstructionBase.

Definition at line 246 of file ElementLoopUserObject.C.

Referenced by SlopeReconstructionBase::meshChanged().

247 {
248  _interface_elem_ids.clear();
249  _have_interface_elems = false;
250 }
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...
bool _have_interface_elems
true if we have cached interface elements, false if they need to be cached. We want to (re)cache only...
void ElementLoopUserObject::onBoundary ( const Elem *  elem,
unsigned int  side,
BoundaryID  bnd_id 
)
virtualinherited

Definition at line 153 of file ElementLoopUserObject.C.

Referenced by ElementLoopUserObject::execute().

154 {
155  _current_side = side;
156  computeBoundary();
157 }
void ElementLoopUserObject::onElement ( const Elem *  elem)
virtualinherited

Definition at line 146 of file ElementLoopUserObject.C.

Referenced by ElementLoopUserObject::execute().

147 {
148  _current_elem = elem;
149  computeElement();
150 }
void ElementLoopUserObject::onInterface ( const Elem *  elem,
unsigned int  side,
BoundaryID  bnd_id 
)
virtualinherited

Definition at line 188 of file ElementLoopUserObject.C.

Referenced by ElementLoopUserObject::execute().

189 {
190  _current_elem = elem;
191  // Pointer to the neighbor we are currently working on.
192  _current_neighbor = elem->neighbor(side);
193 
194  // Get the global id of the element and the neighbor
195  const dof_id_type elem_id = elem->id();
196  const dof_id_type neighbor_id = _current_neighbor->id();
197 
198  // TODO: add if-statement to check if this needs to be executed
199  if ((_current_neighbor->active() && (_current_neighbor->level() == elem->level()) &&
200  (elem_id < neighbor_id)) ||
201  (_current_neighbor->level() < elem->level()))
202  {
204  }
205 
206  if (!_have_interface_elems &&
207  (_current_elem->processor_id() != _current_neighbor->processor_id()))
208  {
209  // if my current neighbor is on another processor store the current element
210  // ID for later communication
211  _interface_elem_ids.insert(_current_elem->id());
212  }
213 }
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...
bool _have_interface_elems
true if we have cached interface elements, false if they need to be cached. We want to (re)cache only...
void ElementLoopUserObject::onInternalSide ( const Elem *  elem,
unsigned int  side 
)
virtualinherited

Definition at line 160 of file ElementLoopUserObject.C.

Referenced by ElementLoopUserObject::execute().

161 {
162  _current_elem = elem;
163  // Pointer to the neighbor we are currently working on.
164  _current_neighbor = elem->neighbor(side);
165 
166  // Get the global id of the element and the neighbor
167  const dof_id_type elem_id = elem->id();
168  const dof_id_type neighbor_id = _current_neighbor->id();
169 
170  // TODO: add if-statement to check if this needs to be executed
171  if ((_current_neighbor->active() && (_current_neighbor->level() == elem->level()) &&
172  (elem_id < neighbor_id)) ||
173  (_current_neighbor->level() < elem->level()))
174  {
176  }
177 
178  if (!_have_interface_elems &&
179  (_current_elem->processor_id() != _current_neighbor->processor_id()))
180  {
181  // if my current neighbor is on another processor store the current element ID for later
182  // communication
183  _interface_elem_ids.insert(_current_elem->id());
184  }
185 }
virtual void computeInternalSide()
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...
bool _have_interface_elems
true if we have cached interface elements, false if they need to be cached. We want to (re)cache only...
void ElementLoopUserObject::post ( )
virtualinherited

Definition at line 216 of file ElementLoopUserObject.C.

Referenced by ElementLoopUserObject::execute().

217 {
218 }
void ElementLoopUserObject::pre ( )
virtualinherited

Definition at line 136 of file ElementLoopUserObject.C.

Referenced by ElementLoopUserObject::execute().

137 {
138 }
void SlopeLimitingBase::serialize ( std::string &  serialized_buffer)
protectedvirtualinherited

Definition at line 76 of file SlopeLimitingBase.C.

Referenced by SlopeLimitingBase::finalize().

77 {
78  std::ostringstream oss;
79 
80  // First store the number of elements to send
81  unsigned int size = _interface_elem_ids.size();
82  oss.write((char *)&size, sizeof(size));
83 
84  for (auto it = _interface_elem_ids.begin(); it != _interface_elem_ids.end(); ++it)
85  {
86  storeHelper(oss, *it, this);
87  storeHelper(oss, _lslope[*it], this);
88  }
89 
90  // Populate the passed in string pointer with the string stream's buffer contents
91  serialized_buffer.assign(oss.str());
92 }
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...
std::map< dof_id_type, std::vector< RealGradient > > _lslope
store the updated slopes into this map indexed by element ID
void ElementLoopUserObject::subdomainChanged ( )
virtualinherited

Definition at line 141 of file ElementLoopUserObject.C.

Referenced by ElementLoopUserObject::execute().

142 {
143 }

Member Data Documentation

const MooseArray<Real>& ElementLoopUserObject::_coord
protectedinherited

Definition at line 100 of file ElementLoopUserObject.h.

const Elem* ElementLoopUserObject::_current_elem
protectedinherited
const Real& ElementLoopUserObject::_current_elem_volume
protectedinherited
const Elem* ElementLoopUserObject::_current_neighbor
protectedinherited
unsigned int ElementLoopUserObject::_current_side
protectedinherited

Definition at line 94 of file ElementLoopUserObject.h.

Referenced by ElementLoopUserObject::onBoundary().

const SinglePhaseFluidProperties& CNSFVSlopeLimitingOneD::_fp
protected

fluid properties user object

Definition at line 41 of file CNSFVSlopeLimitingOneD.h.

Referenced by limitElementSlope().

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 103 of file ElementLoopUserObject.h.

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

bool SlopeLimitingBase::_include_bc
protectedinherited

option whether to include BCs

Definition at line 48 of file SlopeLimitingBase.h.

Referenced by CNSFVMinmaxSlopeLimiting::limitElementSlope().

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 105 of file ElementLoopUserObject.h.

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

const MooseArray<Real>& ElementLoopUserObject::_JxW
protectedinherited

Definition at line 99 of file ElementLoopUserObject.h.

const MooseArray<Real>& SlopeLimitingBase::_JxW_face
protectedinherited

Definition at line 56 of file SlopeLimitingBase.h.

std::map<dof_id_type, std::vector<RealGradient> > SlopeLimitingBase::_lslope
protectedinherited
MooseMesh& ElementLoopUserObject::_mesh
protectedinherited
const Elem*& SlopeLimitingBase::_neighbor_elem
protectedinherited

the neighboring element

Definition at line 66 of file SlopeLimitingBase.h.

const MooseArray<Point>& SlopeLimitingBase::_normals_face
protectedinherited

Definition at line 57 of file SlopeLimitingBase.h.

SubdomainID ElementLoopUserObject::_old_subdomain
protectedinherited

The subdomain for the last element.

Definition at line 111 of file ElementLoopUserObject.h.

Referenced by ElementLoopUserObject::execute().

const MooseArray<Point>& ElementLoopUserObject::_q_point
protectedinherited

Definition at line 97 of file ElementLoopUserObject.h.

const MooseArray<Point>& SlopeLimitingBase::_q_point_face
protectedinherited

required data for face assembly

Definition at line 54 of file SlopeLimitingBase.h.

QBase*& ElementLoopUserObject::_qrule
protectedinherited

Definition at line 98 of file ElementLoopUserObject.h.

QBase*& SlopeLimitingBase::_qrule_face
protectedinherited

Definition at line 55 of file SlopeLimitingBase.h.

MooseVariable* CNSFVSlopeLimitingOneD::_rho
protected

the input density

Definition at line 34 of file CNSFVSlopeLimitingOneD.h.

Referenced by limitElementSlope().

MooseVariable* CNSFVSlopeLimitingOneD::_rhoe
protected

the input total energy

Definition at line 38 of file CNSFVSlopeLimitingOneD.h.

Referenced by limitElementSlope().

MooseVariable* CNSFVSlopeLimitingOneD::_rhou
protected

the input x-momentum

Definition at line 36 of file CNSFVSlopeLimitingOneD.h.

Referenced by limitElementSlope().

const SlopeReconstructionBase& SlopeLimitingBase::_rslope
protectedinherited
MooseEnum CNSFVSlopeLimitingOneD::_scheme
protected

One-D slope limiting scheme.

Definition at line 44 of file CNSFVSlopeLimitingOneD.h.

Referenced by limitElementSlope().

unsigned int& SlopeLimitingBase::_side
protectedinherited

current side of the current element

Definition at line 60 of file SlopeLimitingBase.h.

const Elem*& SlopeLimitingBase::_side_elem
protectedinherited

Definition at line 62 of file SlopeLimitingBase.h.

const Real& SlopeLimitingBase::_side_volume
protectedinherited

Definition at line 63 of file SlopeLimitingBase.h.

SubdomainID ElementLoopUserObject::_subdomain
protectedinherited

The subdomain for the current element.

Definition at line 108 of file ElementLoopUserObject.h.

Referenced by ElementLoopUserObject::execute().


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