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

A user object that performs the least-squares slope reconstruction to get the slopes of the P0 primitive variables. More...

#include <CNSFVLeastSquaresSlopeReconstruction.h>

Inheritance diagram for CNSFVLeastSquaresSlopeReconstruction:
[legend]

Public Member Functions

 CNSFVLeastSquaresSlopeReconstruction (const InputParameters &parameters)
 
virtual void reconstructElementSlope ()
 compute the 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 to get element slope values More...
 
virtual const std::vector< Real > & getElementAverageValue (dof_id_type elementid) const
 accessor function call to get element average variable values More...
 
virtual const std::vector< Real > & getBoundaryAverageValue (dof_id_type elementid, unsigned int side) const
 accessor function call to get boundary average variable values More...
 
virtual const Point & getSideCentroid (dof_id_type elementid, dof_id_type neighborid) const
 accessor function call to get cached internal side centroid More...
 
virtual const Point & getBoundarySideCentroid (dof_id_type elementid, unsigned int side) const
 accessor function call to get cached boundary side centroid More...
 
virtual const Point & getSideNormal (dof_id_type elementid, dof_id_type neighborid) const
 accessor function call to get cached internal side normal More...
 
virtual const Point & getBoundarySideNormal (dof_id_type elementid, unsigned int side) const
 accessor function call to get cached boundary side centroid More...
 
virtual const Real & getSideArea (dof_id_type elementid, dof_id_type neighborid) const
 accessor function call to get cached internal side area More...
 
virtual const Real & getBoundarySideArea (dof_id_type elementid, unsigned int side) const
 accessor function call to get cached boundary side area More...
 
virtual void meshChanged ()
 
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 ()
 
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 * _rhov
 the input y-momentum More...
 
MooseVariable * _rhow
 the input z-momentum More...
 
MooseVariable * _rhoe
 the input total energy More...
 
const SinglePhaseFluidProperties_fp
 fluid properties user object More...
 
std::map< BoundaryID, UserObjectName > _bnd_uo_name_map
 store the pair of boundary ID and user object name More...
 
std::map< dof_id_type, std::vector< RealGradient > > _rslope
 store the reconstructed slopes into this map indexed by element ID More...
 
std::map< dof_id_type, std::vector< Real > > _avars
 store the average variable values into this map indexed by element ID More...
 
std::map< std::pair< dof_id_type, unsigned int >, std::vector< Real > > _bnd_avars
 store the boundary average variable values into this map indexed by pair of element ID and local side ID More...
 
std::map< std::pair< dof_id_type, dof_id_type >, Point > _side_centroid
 store the side centroid into this map indexed by pair of element ID and neighbor ID More...
 
std::map< std::pair< dof_id_type, unsigned int >, Point > _bnd_side_centroid
 store the boundary side centroid into this map indexed by pair of element ID and local side ID More...
 
std::map< std::pair< dof_id_type, dof_id_type >, Real > _side_area
 store the side area into this map indexed by pair of element ID and neighbor ID More...
 
std::map< std::pair< dof_id_type, unsigned int >, Real > _bnd_side_area
 store the boundary side area into this map indexed by pair of element ID and local side ID More...
 
std::map< std::pair< dof_id_type, dof_id_type >, Point > _side_normal
 store the side normal into this map indexed by pair of element ID and neighbor ID More...
 
std::map< std::pair< dof_id_type, unsigned int >, Point > _bnd_side_normal
 store the boundary side normal into this map indexed by pair of element ID and local side ID 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...
 
bool _side_geoinfo_cached
 flag to indicated if side geometry info is cached 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 user object that performs the least-squares slope reconstruction to get the slopes of the P0 primitive variables.

Definition at line 24 of file CNSFVLeastSquaresSlopeReconstruction.h.

Constructor & Destructor Documentation

CNSFVLeastSquaresSlopeReconstruction::CNSFVLeastSquaresSlopeReconstruction ( const InputParameters &  parameters)

Definition at line 35 of file CNSFVLeastSquaresSlopeReconstruction.C.

37  : SlopeReconstructionMultiD(parameters),
38  _rho(getVar("rho", 0)),
39  _rhou(getVar("rhou", 0)),
40  _rhov(isCoupled("rhov") ? getVar("rhov", 0) : nullptr),
41  _rhow(isCoupled("rhow") ? getVar("rhow", 0) : nullptr),
42  _rhoe(getVar("rhoe", 0)),
43  _fp(getUserObject<SinglePhaseFluidProperties>("fluid_properties"))
44 {
45 }
SlopeReconstructionMultiD(const InputParameters &parameters)
MooseVariable * _rhoe
the input total energy
const SinglePhaseFluidProperties & _fp
fluid properties user object

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 SlopeReconstructionBase::computeElement ( )
virtualinherited

Reimplemented from ElementLoopUserObject.

Definition at line 237 of file SlopeReconstructionBase.C.

238 {
240 }
virtual void reconstructElementSlope()=0
compute the slope of the cell
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 SlopeReconstructionBase::deserialize ( std::vector< std::string > &  serialized_buffers)
protectedvirtualinherited

Definition at line 262 of file SlopeReconstructionBase.C.

Referenced by SlopeReconstructionBase::finalize().

263 {
264  // The input string stream used for deserialization
265  std::istringstream iss;
266 
267  mooseAssert(serialized_buffers.size() == _app.n_processors(),
268  "Unexpected size of serialized_buffers: " << serialized_buffers.size());
269 
270  for (auto rank = decltype(_app.n_processors())(0); rank < serialized_buffers.size(); ++rank)
271  {
272  if (rank == processor_id())
273  continue;
274 
275  iss.str(serialized_buffers[rank]); // populate the stream with a new buffer
276  iss.clear(); // reset the string stream state
277 
278  // Load the communicated data into all of the other processors' slots
279 
280  unsigned int size = 0;
281  iss.read((char *)&size, sizeof(size));
282 
283  for (unsigned int i = 0; i < size; i++)
284  {
285  dof_id_type key;
286  loadHelper(iss, key, this);
287 
288  std::vector<RealGradient> value;
289  loadHelper(iss, value, this);
290 
291  // merge the data we received from other procs
292  _rslope.insert(std::pair<dof_id_type, std::vector<RealGradient>>(key, value));
293  }
294  }
295 }
std::map< dof_id_type, std::vector< RealGradient > > _rslope
store the reconstructed 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 SlopeReconstructionBase::finalize ( )
virtualinherited

Reimplemented from ElementLoopUserObject.

Definition at line 47 of file SlopeReconstructionBase.C.

48 {
50 
51  if (_app.n_processors() > 1)
52  {
53  _side_geoinfo_cached = true;
54 
55  std::vector<std::string> send_buffers(1);
56  std::vector<std::string> recv_buffers;
57 
58  recv_buffers.reserve(_app.n_processors());
59  serialize(send_buffers[0]);
60  comm().allgather_packed_range((void *)(nullptr),
61  send_buffers.begin(),
62  send_buffers.end(),
63  std::back_inserter(recv_buffers));
64  deserialize(recv_buffers);
65  }
66 }
virtual void serialize(std::string &serialized_buffer)
virtual void deserialize(std::vector< std::string > &serialized_buffers)
bool _side_geoinfo_cached
flag to indicated if side geometry info is cached
const std::vector< Real > & SlopeReconstructionBase::getBoundaryAverageValue ( dof_id_type  elementid,
unsigned int  side 
) const
virtualinherited

accessor function call to get boundary average variable values

Definition at line 111 of file SlopeReconstructionBase.C.

Referenced by CNSFVMinmaxSlopeLimiting::limitElementSlope().

112 {
113  Threads::spin_mutex::scoped_lock lock(_mutex);
114  std::map<std::pair<dof_id_type, unsigned int>, std::vector<Real>>::const_iterator pos =
115  _bnd_avars.find(std::pair<dof_id_type, unsigned int>(elementid, side));
116 
117  if (pos == _bnd_avars.end())
118  mooseError("Average variable values are not cached for element id '",
119  elementid,
120  "' and side '",
121  side,
122  "' in ",
123  __FUNCTION__);
124 
125  return pos->second;
126 }
static Threads::spin_mutex _mutex
std::map< std::pair< dof_id_type, unsigned int >, std::vector< Real > > _bnd_avars
store the boundary average variable values into this map indexed by pair of element ID and local side...
const Real & SlopeReconstructionBase::getBoundarySideArea ( dof_id_type  elementid,
unsigned int  side 
) const
virtualinherited

accessor function call to get cached boundary side area

Definition at line 219 of file SlopeReconstructionBase.C.

Referenced by CNSFVGreenGaussSlopeReconstruction::reconstructElementSlope().

220 {
221  Threads::spin_mutex::scoped_lock lock(_mutex);
222  std::map<std::pair<dof_id_type, unsigned int>, Real>::const_iterator pos =
223  _bnd_side_area.find(std::pair<dof_id_type, unsigned int>(elementid, side));
224 
225  if (pos == _bnd_side_area.end())
226  mooseError("Boundary side area values are not cached for element id '",
227  elementid,
228  "' and side '",
229  side,
230  "' in ",
231  __FUNCTION__);
232 
233  return pos->second;
234 }
static Threads::spin_mutex _mutex
std::map< std::pair< dof_id_type, unsigned int >, Real > _bnd_side_area
store the boundary side area into this map indexed by pair of element ID and local side ID ...
const Point & SlopeReconstructionBase::getBoundarySideCentroid ( dof_id_type  elementid,
unsigned int  side 
) const
virtualinherited

accessor function call to get cached boundary side centroid

Definition at line 147 of file SlopeReconstructionBase.C.

Referenced by CNSFVMinmaxSlopeLimiting::limitElementSlope(), CNSFVGreenGaussSlopeReconstruction::reconstructElementSlope(), and reconstructElementSlope().

148 {
149  Threads::spin_mutex::scoped_lock lock(_mutex);
150  std::map<std::pair<dof_id_type, unsigned int>, Point>::const_iterator pos =
151  _bnd_side_centroid.find(std::pair<dof_id_type, unsigned int>(elementid, side));
152 
153  if (pos == _bnd_side_centroid.end())
154  mooseError("Boundary side centroid values are not cached for element id '",
155  elementid,
156  "' and side '",
157  side,
158  "' in ",
159  __FUNCTION__);
160 
161  return pos->second;
162 }
static Threads::spin_mutex _mutex
std::map< std::pair< dof_id_type, unsigned int >, Point > _bnd_side_centroid
store the boundary side centroid into this map indexed by pair of element ID and local side ID ...
const Point & SlopeReconstructionBase::getBoundarySideNormal ( dof_id_type  elementid,
unsigned int  side 
) const
virtualinherited

accessor function call to get cached boundary side centroid

Definition at line 183 of file SlopeReconstructionBase.C.

Referenced by CNSFVGreenGaussSlopeReconstruction::reconstructElementSlope(), and reconstructElementSlope().

184 {
185  Threads::spin_mutex::scoped_lock lock(_mutex);
186  std::map<std::pair<dof_id_type, unsigned int>, Point>::const_iterator pos =
187  _bnd_side_normal.find(std::pair<dof_id_type, unsigned int>(elementid, side));
188 
189  if (pos == _bnd_side_normal.end())
190  mooseError("Boundary side normal values are not cached for element id '",
191  elementid,
192  "' and side '",
193  side,
194  "' in ",
195  __FUNCTION__);
196 
197  return pos->second;
198 }
static Threads::spin_mutex _mutex
std::map< std::pair< dof_id_type, unsigned int >, Point > _bnd_side_normal
store the boundary side normal into this map indexed by pair of element ID and local side ID ...
const std::vector< Real > & SlopeReconstructionBase::getElementAverageValue ( dof_id_type  elementid) const
virtualinherited

accessor function call to get element average variable values

Definition at line 96 of file SlopeReconstructionBase.C.

Referenced by CNSFVMinmaxSlopeLimiting::limitElementSlope().

97 {
98  Threads::spin_mutex::scoped_lock lock(_mutex);
99  std::map<dof_id_type, std::vector<Real>>::const_iterator pos = _avars.find(elementid);
100 
101  if (pos == _avars.end())
102  mooseError("Average variable values are not cached for element id '",
103  elementid,
104  "' in ",
105  __FUNCTION__);
106 
107  return pos->second;
108 }
std::map< dof_id_type, std::vector< Real > > _avars
store the average variable values into this map indexed by element ID
static Threads::spin_mutex _mutex
const std::vector< RealGradient > & SlopeReconstructionBase::getElementSlope ( dof_id_type  elementid) const
virtualinherited

accessor function call to get element slope values

Definition at line 83 of file SlopeReconstructionBase.C.

Referenced by CNSFVNoSlopeLimiting::limitElementSlope(), CNSFVMinmaxSlopeLimiting::limitElementSlope(), and CNSFVWENOSlopeLimiting::limitElementSlope().

84 {
85  Threads::spin_mutex::scoped_lock lock(_mutex);
86  std::map<dof_id_type, std::vector<RealGradient>>::const_iterator pos = _rslope.find(elementid);
87 
88  if (pos == _rslope.end())
89  mooseError(
90  "Reconstructed slope is not cached for element id '", elementid, "' in ", __FUNCTION__);
91 
92  return pos->second;
93 }
static Threads::spin_mutex _mutex
std::map< dof_id_type, std::vector< RealGradient > > _rslope
store the reconstructed slopes into this map indexed by element ID
const Real & SlopeReconstructionBase::getSideArea ( dof_id_type  elementid,
dof_id_type  neighborid 
) const
virtualinherited

accessor function call to get cached internal side area

Definition at line 201 of file SlopeReconstructionBase.C.

Referenced by CNSFVGreenGaussSlopeReconstruction::reconstructElementSlope().

202 {
203  Threads::spin_mutex::scoped_lock lock(_mutex);
204  std::map<std::pair<dof_id_type, dof_id_type>, Real>::const_iterator pos =
205  _side_area.find(std::pair<dof_id_type, dof_id_type>(elementid, neighborid));
206 
207  if (pos == _side_area.end())
208  mooseError("Side area values are not cached for element id '",
209  elementid,
210  "' and neighbor id '",
211  neighborid,
212  "' in ",
213  __FUNCTION__);
214 
215  return pos->second;
216 }
std::map< std::pair< dof_id_type, dof_id_type >, Real > _side_area
store the side area into this map indexed by pair of element ID and neighbor ID
static Threads::spin_mutex _mutex
const Point & SlopeReconstructionBase::getSideCentroid ( dof_id_type  elementid,
dof_id_type  neighborid 
) const
virtualinherited

accessor function call to get cached internal side centroid

Definition at line 129 of file SlopeReconstructionBase.C.

Referenced by CNSFVMinmaxSlopeLimiting::limitElementSlope(), and CNSFVGreenGaussSlopeReconstruction::reconstructElementSlope().

130 {
131  Threads::spin_mutex::scoped_lock lock(_mutex);
132  std::map<std::pair<dof_id_type, dof_id_type>, Point>::const_iterator pos =
133  _side_centroid.find(std::pair<dof_id_type, dof_id_type>(elementid, neighborid));
134 
135  if (pos == _side_centroid.end())
136  mooseError("Side centroid values are not cached for element id '",
137  elementid,
138  "' and neighbor id '",
139  neighborid,
140  "' in ",
141  __FUNCTION__);
142 
143  return pos->second;
144 }
static Threads::spin_mutex _mutex
std::map< std::pair< dof_id_type, dof_id_type >, Point > _side_centroid
store the side centroid into this map indexed by pair of element ID and neighbor ID ...
const Point & SlopeReconstructionBase::getSideNormal ( dof_id_type  elementid,
dof_id_type  neighborid 
) const
virtualinherited

accessor function call to get cached internal side normal

Definition at line 165 of file SlopeReconstructionBase.C.

Referenced by CNSFVGreenGaussSlopeReconstruction::reconstructElementSlope().

166 {
167  Threads::spin_mutex::scoped_lock lock(_mutex);
168  std::map<std::pair<dof_id_type, dof_id_type>, Point>::const_iterator pos =
169  _side_normal.find(std::pair<dof_id_type, dof_id_type>(elementid, neighborid));
170 
171  if (pos == _side_normal.end())
172  mooseError("Side normal values are not cached for element id '",
173  elementid,
174  "' and neighbor id '",
175  neighborid,
176  "' in ",
177  __FUNCTION__);
178 
179  return pos->second;
180 }
static Threads::spin_mutex _mutex
std::map< std::pair< dof_id_type, dof_id_type >, Point > _side_normal
store the side normal into this map indexed by pair of element ID and neighbor ID ...
void SlopeReconstructionBase::initialize ( )
virtualinherited

Reimplemented from ElementLoopUserObject.

Definition at line 38 of file SlopeReconstructionBase.C.

39 {
41 
42  _rslope.clear();
43  _avars.clear();
44 }
std::map< dof_id_type, std::vector< Real > > _avars
store the average variable values into this map indexed by element ID
std::map< dof_id_type, std::vector< RealGradient > > _rslope
store the reconstructed 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; }
void SlopeReconstructionBase::meshChanged ( )
virtualinherited

Reimplemented from ElementLoopUserObject.

Definition at line 69 of file SlopeReconstructionBase.C.

70 {
72 
73  _side_geoinfo_cached = false;
74  _side_centroid.clear();
75  _bnd_side_centroid.clear();
76  _side_normal.clear();
77  _bnd_side_normal.clear();
78  _side_area.clear();
79  _bnd_side_area.clear();
80 }
std::map< std::pair< dof_id_type, dof_id_type >, Real > _side_area
store the side area into this map indexed by pair of element ID and neighbor ID
std::map< std::pair< dof_id_type, dof_id_type >, Point > _side_normal
store the side normal into this map indexed by pair of element ID and neighbor ID ...
std::map< std::pair< dof_id_type, unsigned int >, Point > _bnd_side_normal
store the boundary side normal into this map indexed by pair of element ID and local side ID ...
std::map< std::pair< dof_id_type, dof_id_type >, Point > _side_centroid
store the side centroid into this map indexed by pair of element ID and neighbor ID ...
std::map< std::pair< dof_id_type, unsigned int >, Point > _bnd_side_centroid
store the boundary side centroid into this map indexed by pair of element ID and local side ID ...
std::map< std::pair< dof_id_type, unsigned int >, Real > _bnd_side_area
store the boundary side area into this map indexed by pair of element ID and local side ID ...
bool _side_geoinfo_cached
flag to indicated if side geometry info is cached
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 CNSFVLeastSquaresSlopeReconstruction::reconstructElementSlope ( )
virtual

compute the slope of the cell

current element id

number of sides surrounding an element

number of conserved variables

vector for the reconstructed gradients of the conserved variables

local side normal

local side centroid

local distance between centroids

vector for the cell-average values in the central cell and its neighbors

get average conserved variables in the central cell and convert them into primitive variables

cache the average variable values of the current element

LHS matrix components

inverse of LHS matrix compoenents

RHS vector components

coefficients

helpful scalars

helpful vectors

a flag to indicate boundary element

loop over the sides to compute the reconstructed slope of this cell

for internal side

get conserved variables in the current neighbor and convert them into primitive variables

cache the average variable values of neighbor element

form the matrix-vector components

for boundary side

get the cell-average values of this ghost cell

convert into primitive variables

cache the average variable values of ghost element

form the matrix-vector components

solve Ax=B using the normal equation approach

Implements SlopeReconstructionBase.

Definition at line 48 of file CNSFVLeastSquaresSlopeReconstruction.C.

49 {
50  const Elem * elem = _current_elem;
51 
53  dof_id_type elemID = elem->id();
54 
56  unsigned int nside = elem->n_sides();
57 
59  unsigned int nvars = 5;
60 
62  std::vector<RealGradient> ugrad(nvars, RealGradient(0., 0., 0.));
63 
65  Point snorm = Point(0., 0., 0.);
66 
68  Point scent = Point(0., 0., 0.);
69 
71  Point dcent = Point(0., 0., 0.);
72 
74  std::vector<std::vector<Real>> u(nside + 1, std::vector<Real>(nvars, 0.));
75 
78 
79  Real rhoc = _rho->getElementalValue(elem);
80  Real rhomc = 1. / rhoc;
81  Real rhouc = _rhou->getElementalValue(elem);
82  Real rhovc = 0.;
83  Real rhowc = 0.;
84  Real rhoec = _rhoe->getElementalValue(elem);
85  if (_rhov != nullptr)
86  rhovc = _rhov->getElementalValue(elem);
87  if (_rhow != nullptr)
88  rhowc = _rhow->getElementalValue(elem);
89 
90  u[0][1] = rhouc * rhomc;
91  u[0][2] = rhovc * rhomc;
92  u[0][3] = rhowc * rhomc;
93  Real eintc = rhoec * rhomc - 0.5 * (u[0][1] * u[0][1] + u[0][2] * u[0][2] + u[0][3] * u[0][3]);
94  u[0][0] = _fp.pressure(rhomc, eintc);
95  u[0][4] = _fp.temperature(rhomc, eintc);
96 
98  _avars[elemID] = u[0];
99 
101  Real A11 = 0., A12 = 0., A13 = 0., A22 = 0., A23 = 0., A33 = 0.;
102 
104  Real C11 = 0., C12 = 0., C13 = 0., C21 = 0., C22 = 0., C23 = 0., C31 = 0., C32 = 0., C33 = 0.;
105 
107  std::vector<Real> B1(nvars, 0.);
108  std::vector<Real> B2(nvars, 0.);
109  std::vector<Real> B3(nvars, 0.);
110 
112  Real lspow = 2., lswei = 0.;
113 
115  Real invdet = 0., dx = 0., dy = 0., dz = 0.;
116 
118  std::vector<Real> du(nvars, 0.);
119 
121  bool bndElem = false;
122 
124 
125  for (unsigned int is = 0; is < nside; is++)
126  {
127  unsigned int in = is + 1;
128  const Elem * neig = elem->neighbor_ptr(is);
129 
131 
132  if (neig != nullptr && this->hasBlocks(neig->subdomain_id()))
133  {
134  dof_id_type neigID = neig->id();
135 
137  {
138  _assembly.reinit(elem, is);
139  _side_centroid[std::pair<dof_id_type, dof_id_type>(elemID, neigID)] =
140  _side_elem->centroid();
141  }
142 
145 
146  Real v = 1. / _rho->getElementalValue(neig);
147 
148  u[in][1] = _rhou->getElementalValue(neig) * v;
149  if (_rhov != nullptr)
150  u[in][2] = _rhov->getElementalValue(neig) * v;
151  if (_rhow != nullptr)
152  u[in][3] = _rhow->getElementalValue(neig) * v;
153 
154  Real e = _rhoe->getElementalValue(neig) * v -
155  0.5 * (u[in][1] * u[in][1] + u[in][2] * u[in][2] + u[in][3] * u[in][3]);
156 
157  u[in][0] = _fp.pressure(v, e);
158  u[in][4] = _fp.temperature(v, e);
159 
161  _avars[neigID] = u[in];
162 
164 
165  dcent = neig->centroid() - elem->centroid();
166 
167  lswei = std::sqrt(dcent * dcent);
168 
169  lswei = std::pow(lswei, -lspow);
170 
171  for (unsigned int iv = 0; iv < nvars; iv++)
172  du[iv] = u[in][iv] - u[0][iv];
173 
174  if (_mesh.dimension() > 0)
175  {
176  dx = dcent(0);
177  A11 += lswei * dx * dx;
178  for (unsigned int iv = 0; iv < nvars; iv++)
179  B1[iv] += lswei * du[iv] * dx;
180  }
181  if (_mesh.dimension() > 1)
182  {
183  dy = dcent(1);
184  A12 += lswei * dx * dy;
185  A22 += lswei * dy * dy;
186  for (unsigned int iv = 0; iv < nvars; iv++)
187  B2[iv] += lswei * du[iv] * dy;
188  }
189  if (_mesh.dimension() > 2)
190  {
191  dz = dcent(2);
192  A13 += lswei * dx * dz;
193  A23 += lswei * dy * dz;
194  A33 += lswei * dz * dz;
195  for (unsigned int iv = 0; iv < nvars; iv++)
196  B3[iv] += lswei * du[iv] * dz;
197  }
198  }
199 
201 
202  else
203  {
204  bndElem = true;
205 
207  {
208  scent = getBoundarySideCentroid(elemID, is);
209  snorm = getBoundarySideNormal(elemID, is);
210  }
211  else
212  {
213  _assembly.reinit(elem, is);
214  scent = _side_elem->centroid();
215  snorm = _normals_face[0];
216  _bnd_side_centroid[std::pair<dof_id_type, unsigned int>(elemID, is)] = scent;
217  _bnd_side_normal[std::pair<dof_id_type, unsigned int>(elemID, is)] = snorm;
218  }
219 
221 
222  std::vector<BoundaryID> bndID = _mesh.getBoundaryIDs(elem, is);
223 
224  for (unsigned int ib = 0; ib < bndID.size(); ib++)
225  {
226  BoundaryID currentID = bndID[ib];
227 
228  std::map<BoundaryID, UserObjectName>::const_iterator pos = _bnd_uo_name_map.find(currentID);
229 
230  if (pos != _bnd_uo_name_map.end())
231  {
232  const BCUserObject & bcuo =
233  GeneralUserObject::_fe_problem.getUserObject<BCUserObject>(pos->second);
234 
235  // another question is if we can use (rho,u,v,w,p) as primitive variabls
236  // instead of the current (p,u,v,w,T)
237  // TODO test it in 1D problems first
238 
239  std::vector<Real> uvec1 = {rhoc, rhouc, rhovc, rhowc, rhoec};
240 
241  u[in] = bcuo.getGhostCellValue(is, elem->id(), uvec1, snorm);
242 
244 
245  Real rhog = u[in][0];
246  Real rhoug = u[in][1];
247  Real rhovg = u[in][2];
248  Real rhowg = u[in][3];
249  Real rhoeg = u[in][4];
250 
251  Real rhomg = 1. / rhog;
252 
253  u[in][1] = rhoug * rhomg;
254  u[in][2] = rhovg * rhomg;
255  u[in][3] = rhowg * rhomg;
256 
257  Real eintg = rhoeg * rhomg -
258  0.5 * (u[in][1] * u[in][1] + u[in][2] * u[in][2] + u[in][3] * u[in][3]);
259 
260  u[in][0] = _fp.pressure(rhomg, eintg);
261  u[in][4] = _fp.temperature(rhomg, eintg);
262  }
263  }
264 
266  _bnd_avars[std::pair<dof_id_type, unsigned int>(elemID, is)] = u[in];
267 
269 
270  dcent = 2. * (scent - elem->centroid());
271 
272  lswei = std::sqrt(dcent * dcent);
273 
274  lswei = std::pow(lswei, -lspow);
275 
276  for (unsigned int iv = 0; iv < nvars; iv++)
277  du[iv] = u[in][iv] - u[0][iv];
278 
279  if (_mesh.dimension() > 0)
280  {
281  dx = dcent(0);
282  A11 += lswei * dx * dx;
283  for (unsigned int iv = 0; iv < nvars; iv++)
284  B1[iv] += lswei * du[iv] * dx;
285  }
286  if (_mesh.dimension() > 1)
287  {
288  dy = dcent(1);
289  A12 += lswei * dx * dy;
290  A22 += lswei * dy * dy;
291  for (unsigned int iv = 0; iv < nvars; iv++)
292  B2[iv] += lswei * du[iv] * dy;
293  }
294  if (_mesh.dimension() > 2)
295  {
296  dz = dcent(2);
297  A13 += lswei * dx * dz;
298  A23 += lswei * dy * dz;
299  A33 += lswei * dz * dz;
300  for (unsigned int iv = 0; iv < nvars; iv++)
301  B3[iv] += lswei * du[iv] * dz;
302  }
303  }
304  }
305 
307 
308  if (_mesh.dimension() == 1)
309  {
310  for (unsigned int iv = 0; iv < nvars; iv++)
311  ugrad[iv](0) = B1[iv] / A11;
312  }
313  else if (_mesh.dimension() == 2)
314  {
315  invdet = 1. / (A11 * A22 - A12 * A12);
316 
317  for (unsigned int iv = 0; iv < nvars; iv++)
318  {
319  ugrad[iv](0) = invdet * (A22 * B1[iv] - A12 * B2[iv]);
320  ugrad[iv](1) = invdet * (-A12 * B1[iv] + A11 * B2[iv]);
321  }
322  }
323  else if (_mesh.dimension() == 3)
324  {
325  C11 = A22 * A33 - A23 * A23;
326  C12 = A13 * A23 - A12 * A33;
327  C13 = A12 * A23 - A13 * A22;
328 
329  C21 = A13 * A23 - A12 * A33;
330  C22 = A11 * A33 - A13 * A13;
331  C23 = A12 * A13 - A11 * A23;
332 
333  C31 = A12 * A23 - A22 * A13;
334  C32 = A12 * A13 - A11 * A23;
335  C33 = A11 * A22 - A12 * A12;
336 
337  invdet = 1. / (A11 * C11 + A12 * C12 + A13 * C12);
338 
339  for (unsigned int iv = 0; iv < nvars; iv++)
340  {
341  ugrad[iv](0) = invdet * (C11 * B1[iv] + C12 * B2[iv] + C13 * B3[iv]);
342  ugrad[iv](1) = invdet * (C21 * B1[iv] + C22 * B2[iv] + C23 * B3[iv]);
343  ugrad[iv](2) = invdet * (C31 * B1[iv] + C32 * B2[iv] + C33 * B3[iv]);
344  }
345  }
346 
347  _rslope[elemID] = ugrad;
348 }
virtual Real temperature(Real v, Real u) const =0
Temperature as a function of specific internal energy and specific volume.
std::map< dof_id_type, std::vector< Real > > _avars
store the average variable values into this map indexed by element ID
MooseVariable * _rhoe
the input total energy
const SinglePhaseFluidProperties & _fp
fluid properties user object
std::map< BoundaryID, UserObjectName > _bnd_uo_name_map
store the pair of boundary ID and user object name
std::map< dof_id_type, std::vector< RealGradient > > _rslope
store the reconstructed slopes into this map indexed by element ID
std::map< std::pair< dof_id_type, unsigned int >, Point > _bnd_side_normal
store the boundary side normal into this map indexed by pair of element ID and local side ID ...
virtual const Point & getBoundarySideNormal(dof_id_type elementid, unsigned int side) const
accessor function call to get cached boundary side centroid
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)
const MooseArray< Point > & _normals_face
virtual std::vector< Real > getGhostCellValue(unsigned int iside, dof_id_type ielem, const std::vector< Real > &uvec1, const RealVectorValue &dwave) const =0
compute the ghost cell variable values
A base class of user object for calculating the variable values in ghost element according to specifi...
Definition: BCUserObject.h:42
std::map< std::pair< dof_id_type, dof_id_type >, Point > _side_centroid
store the side centroid into this map indexed by pair of element ID and neighbor ID ...
std::map< std::pair< dof_id_type, unsigned int >, Point > _bnd_side_centroid
store the boundary side centroid into this map indexed by pair of element ID and local side ID ...
virtual const Point & getBoundarySideCentroid(dof_id_type elementid, unsigned int side) const
accessor function call to get cached boundary side centroid
virtual Real pressure(Real v, Real u) const =0
Pressure as a function of specific internal energy and specific volume.
bool _side_geoinfo_cached
flag to indicated if side geometry info is cached
std::map< std::pair< dof_id_type, unsigned int >, std::vector< Real > > _bnd_avars
store the boundary average variable values into this map indexed by pair of element ID and local side...
void SlopeReconstructionBase::serialize ( std::string &  serialized_buffer)
protectedvirtualinherited

Definition at line 243 of file SlopeReconstructionBase.C.

Referenced by SlopeReconstructionBase::finalize().

244 {
245  std::ostringstream oss;
246 
247  // First store the number of elements to send
248  unsigned int size = _interface_elem_ids.size();
249  oss.write((char *)&size, sizeof(size));
250 
251  for (auto it = _interface_elem_ids.begin(); it != _interface_elem_ids.end(); ++it)
252  {
253  storeHelper(oss, *it, this);
254  storeHelper(oss, _rslope[*it], this);
255  }
256 
257  // Populate the passed in string pointer with the string stream's buffer contents
258  serialized_buffer.assign(oss.str());
259 }
std::map< dof_id_type, std::vector< RealGradient > > _rslope
store the reconstructed slopes into this map indexed by element ID
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...
void ElementLoopUserObject::subdomainChanged ( )
virtualinherited

Definition at line 141 of file ElementLoopUserObject.C.

Referenced by ElementLoopUserObject::execute().

142 {
143 }

Member Data Documentation

std::map<dof_id_type, std::vector<Real> > SlopeReconstructionBase::_avars
protectedinherited
std::map<std::pair<dof_id_type, unsigned int>, std::vector<Real> > SlopeReconstructionBase::_bnd_avars
protectedinherited

store the boundary average variable values into this map indexed by pair of element ID and local side ID

Definition at line 78 of file SlopeReconstructionBase.h.

Referenced by SlopeReconstructionBase::getBoundaryAverageValue(), CNSFVGreenGaussSlopeReconstruction::reconstructElementSlope(), and reconstructElementSlope().

std::map<std::pair<dof_id_type, unsigned int>, Real> SlopeReconstructionBase::_bnd_side_area
protectedinherited

store the boundary side area into this map indexed by pair of element ID and local side ID

Definition at line 90 of file SlopeReconstructionBase.h.

Referenced by SlopeReconstructionBase::getBoundarySideArea(), SlopeReconstructionBase::meshChanged(), and CNSFVGreenGaussSlopeReconstruction::reconstructElementSlope().

std::map<std::pair<dof_id_type, unsigned int>, Point> SlopeReconstructionBase::_bnd_side_centroid
protectedinherited

store the boundary side centroid into this map indexed by pair of element ID and local side ID

Definition at line 84 of file SlopeReconstructionBase.h.

Referenced by SlopeReconstructionBase::getBoundarySideCentroid(), SlopeReconstructionBase::meshChanged(), CNSFVGreenGaussSlopeReconstruction::reconstructElementSlope(), and reconstructElementSlope().

std::map<std::pair<dof_id_type, unsigned int>, Point> SlopeReconstructionBase::_bnd_side_normal
protectedinherited

store the boundary side normal into this map indexed by pair of element ID and local side ID

Definition at line 96 of file SlopeReconstructionBase.h.

Referenced by SlopeReconstructionBase::getBoundarySideNormal(), SlopeReconstructionBase::meshChanged(), CNSFVGreenGaussSlopeReconstruction::reconstructElementSlope(), and reconstructElementSlope().

std::map<BoundaryID, UserObjectName> SlopeReconstructionMultiD::_bnd_uo_name_map
protectedinherited
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& CNSFVLeastSquaresSlopeReconstruction::_fp
protected

fluid properties user object

Definition at line 45 of file CNSFVLeastSquaresSlopeReconstruction.h.

Referenced by reconstructElementSlope().

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

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>& SlopeReconstructionBase::_JxW_face
protectedinherited

Definition at line 101 of file SlopeReconstructionBase.h.

MooseMesh& ElementLoopUserObject::_mesh
protectedinherited
const Elem*& SlopeReconstructionBase::_neighbor_elem
protectedinherited

the neighboring element

Definition at line 111 of file SlopeReconstructionBase.h.

const MooseArray<Point>& SlopeReconstructionBase::_normals_face
protectedinherited
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>& SlopeReconstructionBase::_q_point_face
protectedinherited

required data for face assembly

Definition at line 99 of file SlopeReconstructionBase.h.

QBase*& ElementLoopUserObject::_qrule
protectedinherited

Definition at line 98 of file ElementLoopUserObject.h.

QBase*& SlopeReconstructionBase::_qrule_face
protectedinherited

Definition at line 100 of file SlopeReconstructionBase.h.

MooseVariable* CNSFVLeastSquaresSlopeReconstruction::_rho
protected

the input density

Definition at line 34 of file CNSFVLeastSquaresSlopeReconstruction.h.

Referenced by reconstructElementSlope().

MooseVariable* CNSFVLeastSquaresSlopeReconstruction::_rhoe
protected

the input total energy

Definition at line 42 of file CNSFVLeastSquaresSlopeReconstruction.h.

Referenced by reconstructElementSlope().

MooseVariable* CNSFVLeastSquaresSlopeReconstruction::_rhou
protected

the input x-momentum

Definition at line 36 of file CNSFVLeastSquaresSlopeReconstruction.h.

Referenced by reconstructElementSlope().

MooseVariable* CNSFVLeastSquaresSlopeReconstruction::_rhov
protected

the input y-momentum

Definition at line 38 of file CNSFVLeastSquaresSlopeReconstruction.h.

Referenced by reconstructElementSlope().

MooseVariable* CNSFVLeastSquaresSlopeReconstruction::_rhow
protected

the input z-momentum

Definition at line 40 of file CNSFVLeastSquaresSlopeReconstruction.h.

Referenced by reconstructElementSlope().

std::map<dof_id_type, std::vector<RealGradient> > SlopeReconstructionBase::_rslope
protectedinherited
unsigned int& SlopeReconstructionBase::_side
protectedinherited

current side of the current element

Definition at line 105 of file SlopeReconstructionBase.h.

std::map<std::pair<dof_id_type, dof_id_type>, Real> SlopeReconstructionBase::_side_area
protectedinherited

store the side area into this map indexed by pair of element ID and neighbor ID

Definition at line 87 of file SlopeReconstructionBase.h.

Referenced by SlopeReconstructionBase::getSideArea(), SlopeReconstructionBase::meshChanged(), and CNSFVGreenGaussSlopeReconstruction::reconstructElementSlope().

std::map<std::pair<dof_id_type, dof_id_type>, Point> SlopeReconstructionBase::_side_centroid
protectedinherited

store the side centroid into this map indexed by pair of element ID and neighbor ID

Definition at line 81 of file SlopeReconstructionBase.h.

Referenced by SlopeReconstructionBase::getSideCentroid(), SlopeReconstructionBase::meshChanged(), CNSFVGreenGaussSlopeReconstruction::reconstructElementSlope(), and reconstructElementSlope().

const Elem*& SlopeReconstructionBase::_side_elem
protectedinherited
bool SlopeReconstructionBase::_side_geoinfo_cached
protectedinherited
std::map<std::pair<dof_id_type, dof_id_type>, Point> SlopeReconstructionBase::_side_normal
protectedinherited

store the side normal into this map indexed by pair of element ID and neighbor ID

Definition at line 93 of file SlopeReconstructionBase.h.

Referenced by SlopeReconstructionBase::getSideNormal(), SlopeReconstructionBase::meshChanged(), and CNSFVGreenGaussSlopeReconstruction::reconstructElementSlope().

const Real& SlopeReconstructionBase::_side_volume
protectedinherited
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: