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

#include <LevelSetCutUserObject.h>

Inheritance diagram for LevelSetCutUserObject:
[legend]

Public Member Functions

 LevelSetCutUserObject (const InputParameters &parameters)
 
virtual bool cutElementByGeometry (const Elem *elem, std::vector< Xfem::CutEdge > &cut_edges, std::vector< Xfem::CutNode > &cut_nodes, Real time) const override
 Check to see whether a specified 2D element should be cut based on geometric conditions. More...
 
virtual bool cutElementByGeometry (const Elem *elem, std::vector< Xfem::CutFace > &cut_faces, Real time) const override
 Check to see whether a specified 3D element should be cut based on geometric conditions. More...
 
virtual bool cutFragmentByGeometry (std::vector< std::vector< Point >> &frag_edges, std::vector< Xfem::CutEdge > &cut_edges, Real time) const override
 Check to see whether a fragment of a 2D element should be cut based on geometric conditions. More...
 
virtual bool cutFragmentByGeometry (std::vector< std::vector< Point >> &frag_faces, std::vector< Xfem::CutFace > &cut_faces, Real time) const override
 Check to see whether a fragment of a 3D element should be cut based on geometric conditions. More...
 
virtual const std::vector< Point > getCrackFrontPoints (unsigned int num_crack_front_points) const override
 get a set of points along a crack front from a XFEM GeometricCutUserObject More...
 
virtual void initialize () override
 
virtual void execute () override
 
virtual void threadJoin (const UserObject &y) override
 
virtual void finalize () override
 
unsigned int getInterfaceID () const
 Get the interface ID for this cutting object. More...
 
void setInterfaceID (unsigned int interface_id)
 Set the interface ID for this cutting object. More...
 
bool shouldHealMesh () const
 Should the elements cut by this cutting object be healed in the current time step? More...
 

Protected Member Functions

void serialize (std::string &serialized_buffer)
 Methods to pack/unpack the _marked_elems_2d and _marked_elems_3d data into a structure suitable for parallel communication. More...
 
void deserialize (std::vector< std::string > &serialized_buffers)
 

Protected Attributes

const unsigned int _level_set_var_number
 The variable number of the level set variable we using to define the cuts. More...
 
const System & _system
 system reference More...
 
const NumericVector< Number > * _solution
 the subproblem solution vector More...
 
std::shared_ptr< XFEM_xfem
 Pointer to the XFEM controller object. More...
 
unsigned int _interface_id
 Associated interface id. More...
 
bool _heal_always
 Heal the mesh. More...
 
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo2D > > _marked_elems_2d
 Containers with information about all 2D and 3D elements marked for cutting by this object. More...
 
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo3D > > _marked_elems_3d
 

Detailed Description

Definition at line 18 of file LevelSetCutUserObject.h.

Constructor & Destructor Documentation

◆ LevelSetCutUserObject()

LevelSetCutUserObject::LevelSetCutUserObject ( const InputParameters &  parameters)

Definition at line 25 of file LevelSetCutUserObject.C.

26  : GeometricCutUserObject(parameters),
27  _level_set_var_number(_subproblem
28  .getVariable(_tid,
29  parameters.get<VariableName>("level_set_var"),
30  Moose::VarKindType::VAR_ANY,
31  Moose::VarFieldType::VAR_FIELD_STANDARD)
32  .number()),
33  _system(_subproblem.getSystem(getParam<VariableName>("level_set_var"))),
34  _solution(_system.current_local_solution.get())
35 {
36 }
const NumericVector< Number > * _solution
the subproblem solution vector
const unsigned int _level_set_var_number
The variable number of the level set variable we using to define the cuts.
const System & _system
system reference
GeometricCutUserObject(const InputParameters &parameters)
Factory constructor, takes parameters so that all derived classes can be built using the same constru...

Member Function Documentation

◆ cutElementByGeometry() [1/2]

bool LevelSetCutUserObject::cutElementByGeometry ( const Elem *  elem,
std::vector< Xfem::CutEdge > &  cut_edges,
std::vector< Xfem::CutNode > &  cut_nodes,
Real  time 
) const
overridevirtual

Check to see whether a specified 2D element should be cut based on geometric conditions.

Parameters
elemPointer to the libMesh element to be considered for cutting
cut_edgesData structure filled with information about edges to be cut
cut_nodesData structure filled with information about nodes to be cut
timeCurrent simulation time
Returns
bool true if element is to be cut

Implements GeometricCutUserObject.

Definition at line 39 of file LevelSetCutUserObject.C.

43 {
44  bool cut_elem = false;
45 
46  unsigned int n_sides = elem->n_sides();
47 
48  for (unsigned int i = 0; i < n_sides; ++i)
49  {
50  UniquePtr<Elem> curr_side = elem->side(i);
51 
52  if (curr_side->type() != EDGE2)
53  mooseError("In LevelSetCutUserObject element side must be EDGE2, but type is: ",
54  libMesh::Utility::enum_to_string(curr_side->type()),
55  " base element type is: ",
56  libMesh::Utility::enum_to_string(elem->type()));
57 
58  const Node * node1 = curr_side->get_node(0);
59  const Node * node2 = curr_side->get_node(1);
60 
61  dof_id_type ls_dof_id_1 = node1->dof_number(_system.number(), _level_set_var_number, 0);
62  dof_id_type ls_dof_id_2 = node2->dof_number(_system.number(), _level_set_var_number, 0);
63 
64  Number ls_node_1 = (*_solution)(ls_dof_id_1);
65  Number ls_node_2 = (*_solution)(ls_dof_id_2);
66 
67  if (ls_node_1 * ls_node_2 < 0)
68  {
69  cut_elem = true;
70  Xfem::CutEdge mycut;
71  mycut._id1 = node1->id();
72  mycut._id2 = node2->id();
73  Real seg_int_frac = std::abs(ls_node_1) / std::abs(ls_node_1 - ls_node_2);
74  mycut._distance = seg_int_frac;
75  mycut._host_side_id = i;
76  cut_edges.push_back(mycut);
77  }
78  }
79 
80  return cut_elem;
81 }
const unsigned int _level_set_var_number
The variable number of the level set variable we using to define the cuts.
const System & _system
system reference
Data structure defining a cut on an element edge.
unsigned int _id1
ID of the first node on the edge.
Real _distance
Fractional distance along the edge (from node 1 to 2) where the cut is located.
unsigned int _id2
ID of the second node on the edge.
unsigned int _host_side_id
Local ID of this side in the host element.

◆ cutElementByGeometry() [2/2]

bool LevelSetCutUserObject::cutElementByGeometry ( const Elem *  elem,
std::vector< Xfem::CutFace > &  cut_faces,
Real  time 
) const
overridevirtual

Check to see whether a specified 3D element should be cut based on geometric conditions.

Parameters
elemPointer to the libMesh element to be considered for cutting
cut_facesData structure filled with information about edges to be cut
timeCurrent simulation time
Returns
bool true if element is to be cut

Implements GeometricCutUserObject.

Definition at line 84 of file LevelSetCutUserObject.C.

87 {
88  bool cut_elem = false;
89 
90  for (unsigned int i = 0; i < elem->n_sides(); ++i)
91  {
92  std::unique_ptr<Elem> curr_side = elem->side(i);
93  if (curr_side->dim() != 2)
94  mooseError("In LevelSetCutUserObject dimension of side must be 2, but it is ",
95  curr_side->dim());
96  unsigned int n_edges = curr_side->n_sides();
97 
98  std::vector<unsigned int> cut_edges;
99  std::vector<Real> cut_pos;
100 
101  for (unsigned int j = 0; j < n_edges; j++)
102  {
103  // This returns the lowest-order type of side.
104  std::unique_ptr<Elem> curr_edge = curr_side->side(j);
105  if (curr_edge->type() != EDGE2)
106  mooseError("In LevelSetCutUserObject face edge must be EDGE2, but type is: ",
107  libMesh::Utility::enum_to_string(curr_edge->type()),
108  " base element type is: ",
109  libMesh::Utility::enum_to_string(elem->type()));
110 
111  const Node * node1 = curr_edge->get_node(0);
112  const Node * node2 = curr_edge->get_node(1);
113 
114  dof_id_type ls_dof_id_1 = node1->dof_number(_system.number(), _level_set_var_number, 0);
115  dof_id_type ls_dof_id_2 = node2->dof_number(_system.number(), _level_set_var_number, 0);
116 
117  Number ls_node_1 = (*_solution)(ls_dof_id_1);
118  Number ls_node_2 = (*_solution)(ls_dof_id_2);
119 
120  if (ls_node_1 * ls_node_2 < 0)
121  {
122  Real seg_int_frac = std::abs(ls_node_1) / std::abs(ls_node_1 - ls_node_2);
123  cut_edges.push_back(j);
124  cut_pos.push_back(seg_int_frac);
125  }
126  }
127 
128  if (cut_edges.size() == 2)
129  {
130  cut_elem = true;
131  Xfem::CutFace mycut;
132  mycut._face_id = i;
133  mycut._face_edge.push_back(cut_edges[0]);
134  mycut._face_edge.push_back(cut_edges[1]);
135  mycut._position.push_back(cut_pos[0]);
136  mycut._position.push_back(cut_pos[1]);
137  cut_faces.push_back(mycut);
138  }
139  }
140  return cut_elem;
141 }
const unsigned int _level_set_var_number
The variable number of the level set variable we using to define the cuts.
const System & _system
system reference
std::vector< Real > _position
Fractional distance along the cut edges where the cut is located.
Data structure defining a cut through a face.
std::vector< unsigned int > _face_edge
IDs of all cut faces.
unsigned int _face_id
ID of the cut face.

◆ cutFragmentByGeometry() [1/2]

bool LevelSetCutUserObject::cutFragmentByGeometry ( std::vector< std::vector< Point >> &  frag_edges,
std::vector< Xfem::CutEdge > &  cut_edges,
Real  time 
) const
overridevirtual

Check to see whether a fragment of a 2D element should be cut based on geometric conditions.

Parameters
frag_edgesData structure defining the current fragment to be considered
cut_edgesData structure filled with information about fragment edges to be cut
timeCurrent simulation time
Returns
bool true if fragment is to be cut

Implements GeometricCutUserObject.

Definition at line 144 of file LevelSetCutUserObject.C.

147 {
148  return false;
149 }

◆ cutFragmentByGeometry() [2/2]

bool LevelSetCutUserObject::cutFragmentByGeometry ( std::vector< std::vector< Point >> &  frag_faces,
std::vector< Xfem::CutFace > &  cut_faces,
Real  time 
) const
overridevirtual

Check to see whether a fragment of a 3D element should be cut based on geometric conditions.

Parameters
frag_facesData structure defining the current fragment to be considered
cut_facesData structure filled with information about fragment faces to be cut
timeCurrent simulation time
Returns
bool true if fragment is to be cut

Implements GeometricCutUserObject.

Definition at line 152 of file LevelSetCutUserObject.C.

155 {
156  mooseError("cutFragmentByGeometry not yet implemented for 3d level set cutting");
157  return false;
158 }

◆ deserialize()

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

Definition at line 222 of file GeometricCutUserObject.C.

Referenced by GeometricCutUserObject::finalize().

223 {
224  mooseAssert(serialized_buffers.size() == _app.n_processors(),
225  "Unexpected size of serialized_buffers: " << serialized_buffers.size());
226 
227  // The input string stream used for deserialization
228  std::istringstream iss;
229 
230  // Loop over all datastructures for all processors to perfrom the gather operation
231  for (unsigned int rank = 0; rank < serialized_buffers.size(); ++rank)
232  {
233  // skip the current processor (its data is already in the structures)
234  if (rank == processor_id())
235  continue;
236 
237  // populate the stream with a new buffer and reset stream state
238  iss.clear();
239  iss.str(serialized_buffers[rank]);
240 
241  // Load the communicated data into temporary structures
242  std::map<unsigned int, std::vector<Xfem::GeomMarkedElemInfo2D>> other_marked_elems_2d;
243  std::map<unsigned int, std::vector<Xfem::GeomMarkedElemInfo3D>> other_marked_elems_3d;
244  dataLoad(iss, other_marked_elems_2d, this);
245  dataLoad(iss, other_marked_elems_3d, this);
246 
247  // merge the data in with the current processor's data
248  _marked_elems_2d.insert(other_marked_elems_2d.begin(), other_marked_elems_2d.end());
249  _marked_elems_3d.insert(other_marked_elems_3d.begin(), other_marked_elems_3d.end());
250  }
251 }
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo2D > > _marked_elems_2d
Containers with information about all 2D and 3D elements marked for cutting by this object...
void dataLoad(std::istream &stream, Xfem::CutFace &cf, void *context)
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo3D > > _marked_elems_3d

◆ execute()

void GeometricCutUserObject::execute ( )
overridevirtualinherited

Reimplemented in MovingLineSegmentCutSetUserObject.

Definition at line 67 of file GeometricCutUserObject.C.

Referenced by MovingLineSegmentCutSetUserObject::execute().

68 {
69  if (_current_elem->dim() == 2)
70  {
71  std::vector<Xfem::CutEdge> elem_cut_edges;
72  std::vector<Xfem::CutNode> elem_cut_nodes;
73  std::vector<Xfem::CutEdge> frag_cut_edges;
74  std::vector<std::vector<Point>> frag_edges;
75 
76  EFAElement2D * EFAElem = _xfem->getEFAElem2D(_current_elem);
77 
78  // Don't cut again if elem has been already cut twice
79  if (!EFAElem->isFinalCut())
80  {
81  // get fragment edges
82  _xfem->getFragmentEdges(_current_elem, EFAElem, frag_edges);
83 
84  // mark cut edges for the element and its fragment
85  bool cut = cutElementByGeometry(_current_elem, elem_cut_edges, elem_cut_nodes, _t);
86  if (EFAElem->numFragments() > 0)
87  cut |= cutFragmentByGeometry(frag_edges, frag_cut_edges, _t);
88 
89  if (cut)
90  {
92  gmei2d._elem_cut_edges = elem_cut_edges;
93  gmei2d._elem_cut_nodes = elem_cut_nodes;
94  gmei2d._frag_cut_edges = frag_cut_edges;
95  gmei2d._frag_edges = frag_edges;
96  _marked_elems_2d[_current_elem->id()].push_back(gmei2d);
97  }
98  }
99  }
100  else if (_current_elem->dim() == 3)
101  {
102  std::vector<Xfem::CutFace> elem_cut_faces;
103  std::vector<Xfem::CutFace> frag_cut_faces;
104  std::vector<std::vector<Point>> frag_faces;
105 
106  EFAElement3D * EFAElem = _xfem->getEFAElem3D(_current_elem);
107 
108  // Don't cut again if elem has been already cut twice
109  if (!EFAElem->isFinalCut())
110  {
111  // get fragment edges
112  _xfem->getFragmentFaces(_current_elem, EFAElem, frag_faces);
113 
114  // mark cut faces for the element and its fragment
115  bool cut = cutElementByGeometry(_current_elem, elem_cut_faces, _t);
116  // TODO: This would be done for branching, which is not yet supported in 3D
117  // if (EFAElem->numFragments() > 0)
118  // cut |= cutFragmentByGeometry(frag_faces, frag_cut_faces, _t);
119 
120  if (cut)
121  {
123  gmei3d._elem_cut_faces = elem_cut_faces;
124  gmei3d._frag_cut_faces = frag_cut_faces;
125  gmei3d._frag_faces = frag_faces;
126  _marked_elems_3d[_current_elem->id()].push_back(gmei3d);
127  }
128  }
129  }
130 }
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo2D > > _marked_elems_2d
Containers with information about all 2D and 3D elements marked for cutting by this object...
Data structure describing geometrically described cut through 3D element.
virtual bool cutFragmentByGeometry(std::vector< std::vector< Point >> &frag_edges, std::vector< Xfem::CutEdge > &cut_edges, Real time) const =0
Check to see whether a fragment of a 2D element should be cut based on geometric conditions.
virtual unsigned int numFragments() const
Definition: EFAElement2D.C:202
virtual bool cutElementByGeometry(const Elem *elem, std::vector< Xfem::CutEdge > &cut_edges, std::vector< Xfem::CutNode > &cut_nodes, Real time) const =0
Check to see whether a specified 2D element should be cut based on geometric conditions.
std::vector< CutNode > _elem_cut_nodes
Container for data about all cut nodes in this element.
std::vector< CutEdge > _elem_cut_edges
Container for data about all cut edges in this element.
std::vector< std::vector< Point > > _frag_edges
Container for data about all cut edges in cut fragments in this element.
virtual bool isFinalCut() const
Definition: EFAElement2D.C:791
std::vector< CutEdge > _frag_cut_edges
Container for data about all cut fragments in this element.
Data structure describing geometrically described cut through 2D element.
std::shared_ptr< XFEM > _xfem
Pointer to the XFEM controller object.
std::vector< CutFace > _frag_cut_faces
Container for data about all faces this element&#39;s fragment.
std::vector< std::vector< Point > > _frag_faces
Container for data about all cut faces in cut fragments in this element.
std::vector< CutFace > _elem_cut_faces
Container for data about all cut faces in this element.
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo3D > > _marked_elems_3d
virtual bool isFinalCut() const
Definition: EFAElement3D.C:838

◆ finalize()

void GeometricCutUserObject::finalize ( )
overridevirtualinherited

Reimplemented in MovingLineSegmentCutSetUserObject.

Definition at line 254 of file GeometricCutUserObject.C.

Referenced by MovingLineSegmentCutSetUserObject::finalize().

255 {
256  // for single processor runs we do not need to do anything here
257  if (_app.n_processors() > 1)
258  {
259  // create send buffer
260  std::string send_buffer;
261 
262  // create byte buffers for the streams received from all processors
263  std::vector<std::string> recv_buffers;
264 
265  // pack the complex datastructures into the string stream
266  serialize(send_buffer);
267 
268  // broadcast serialized data to and receive from all processors
269  _communicator.allgather(send_buffer, recv_buffers);
270 
271  // unpack the received data and merge it into the local data structures
272  deserialize(recv_buffers);
273  }
274 
275  for (const auto & it : _marked_elems_2d)
276  for (const auto & gmei : it.second)
277  _xfem->addGeomMarkedElem2D(it.first, gmei, _interface_id);
278 
279  for (const auto & it : _marked_elems_3d)
280  for (const auto & gmei : it.second)
281  _xfem->addGeomMarkedElem3D(it.first, gmei, _interface_id);
282 
283  _marked_elems_2d.clear();
284  _marked_elems_3d.clear();
285 }
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo2D > > _marked_elems_2d
Containers with information about all 2D and 3D elements marked for cutting by this object...
unsigned int _interface_id
Associated interface id.
void deserialize(std::vector< std::string > &serialized_buffers)
void serialize(std::string &serialized_buffer)
Methods to pack/unpack the _marked_elems_2d and _marked_elems_3d data into a structure suitable for p...
std::shared_ptr< XFEM > _xfem
Pointer to the XFEM controller object.
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo3D > > _marked_elems_3d

◆ getCrackFrontPoints()

const std::vector< Point > LevelSetCutUserObject::getCrackFrontPoints ( unsigned int  int) const
overridevirtual

get a set of points along a crack front from a XFEM GeometricCutUserObject

Returns
A vector which contains all crack front points

Implements CrackFrontPointsProvider.

Definition at line 161 of file LevelSetCutUserObject.C.

162 {
163  mooseError("getCrackFrontPoints() is not implemented for this object.");
164 }

◆ getInterfaceID()

unsigned int GeometricCutUserObject::getInterfaceID ( ) const
inlineinherited

Get the interface ID for this cutting object.

Returns
the interface ID

Definition at line 173 of file GeometricCutUserObject.h.

173 { return _interface_id; };
unsigned int _interface_id
Associated interface id.

◆ initialize()

void GeometricCutUserObject::initialize ( )
overridevirtualinherited

Reimplemented in MeshCut3DUserObject, and MovingLineSegmentCutSetUserObject.

Definition at line 60 of file GeometricCutUserObject.C.

61 {
62  _marked_elems_2d.clear();
63  _marked_elems_3d.clear();
64 }
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo2D > > _marked_elems_2d
Containers with information about all 2D and 3D elements marked for cutting by this object...
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo3D > > _marked_elems_3d

◆ serialize()

void GeometricCutUserObject::serialize ( std::string &  serialized_buffer)
protectedinherited

Methods to pack/unpack the _marked_elems_2d and _marked_elems_3d data into a structure suitable for parallel communication.

Definition at line 209 of file GeometricCutUserObject.C.

Referenced by GeometricCutUserObject::finalize().

210 {
211  // stream for serializing the _marked_elems_2d and _marked_elems_3d data structures to a byte
212  // stream
213  std::ostringstream oss;
214  dataStore(oss, _marked_elems_2d, this);
215  dataStore(oss, _marked_elems_3d, this);
216 
217  // Populate the passed in string pointer with the string stream's buffer contents
218  serialized_buffer.assign(oss.str());
219 }
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo2D > > _marked_elems_2d
Containers with information about all 2D and 3D elements marked for cutting by this object...
void dataStore(std::ostream &stream, Xfem::CutFace &cf, void *context)
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo3D > > _marked_elems_3d

◆ setInterfaceID()

void GeometricCutUserObject::setInterfaceID ( unsigned int  interface_id)
inlineinherited

Set the interface ID for this cutting object.

Parameters
theinterface ID

Definition at line 179 of file GeometricCutUserObject.h.

Referenced by XFEM::addGeometricCut().

179 { _interface_id = interface_id; };
unsigned int _interface_id
Associated interface id.

◆ shouldHealMesh()

bool GeometricCutUserObject::shouldHealMesh ( ) const
inlineinherited

Should the elements cut by this cutting object be healed in the current time step?

Returns
true if the cut element should be healed

Definition at line 186 of file GeometricCutUserObject.h.

186 { return _heal_always; };
bool _heal_always
Heal the mesh.

◆ threadJoin()

void GeometricCutUserObject::threadJoin ( const UserObject &  y)
overridevirtualinherited

Definition at line 133 of file GeometricCutUserObject.C.

134 {
135  const GeometricCutUserObject & gcuo = dynamic_cast<const GeometricCutUserObject &>(y);
136 
137  for (const auto & it : gcuo._marked_elems_2d)
138  {
139  mooseAssert(_marked_elems_2d.find(it.first) == _marked_elems_2d.end(),
140  "Element already inserted in map from a different thread");
141  _marked_elems_2d[it.first] = it.second;
142  }
143  for (const auto & it : gcuo._marked_elems_3d)
144  {
145  mooseAssert(_marked_elems_3d.find(it.first) == _marked_elems_3d.end(),
146  "Element already inserted in map from a different thread");
147  _marked_elems_3d[it.first] = it.second;
148  }
149 }
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo2D > > _marked_elems_2d
Containers with information about all 2D and 3D elements marked for cutting by this object...
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo3D > > _marked_elems_3d

Member Data Documentation

◆ _heal_always

bool GeometricCutUserObject::_heal_always
protectedinherited

Heal the mesh.

Definition at line 196 of file GeometricCutUserObject.h.

◆ _interface_id

unsigned int GeometricCutUserObject::_interface_id
protectedinherited

Associated interface id.

Definition at line 193 of file GeometricCutUserObject.h.

Referenced by GeometricCutUserObject::finalize(), and GeometricCutUserObject::GeometricCutUserObject().

◆ _level_set_var_number

const unsigned int LevelSetCutUserObject::_level_set_var_number
protected

The variable number of the level set variable we using to define the cuts.

Definition at line 43 of file LevelSetCutUserObject.h.

Referenced by cutElementByGeometry().

◆ _marked_elems_2d

std::map<unsigned int, std::vector<Xfem::GeomMarkedElemInfo2D> > GeometricCutUserObject::_marked_elems_2d
protectedinherited

◆ _marked_elems_3d

std::map<unsigned int, std::vector<Xfem::GeomMarkedElemInfo3D> > GeometricCutUserObject::_marked_elems_3d
protectedinherited

◆ _solution

const NumericVector<Number>* LevelSetCutUserObject::_solution
protected

the subproblem solution vector

Definition at line 49 of file LevelSetCutUserObject.h.

◆ _system

const System& LevelSetCutUserObject::_system
protected

system reference

Definition at line 46 of file LevelSetCutUserObject.h.

Referenced by cutElementByGeometry().

◆ _xfem

std::shared_ptr<XFEM> GeometricCutUserObject::_xfem
protectedinherited

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