www.mooseframework.org
Public Member Functions | Static 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...
 

Static Public Member Functions

static InputParameters validParams ()
 

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...
 
unsigned int _last_step_initialized
 Time step information needed to advance a 3D crack only at the real beginning of a time step. 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 20 of file LevelSetCutUserObject.h.

Constructor & Destructor Documentation

◆ LevelSetCutUserObject()

LevelSetCutUserObject::LevelSetCutUserObject ( const InputParameters &  parameters)

Definition at line 28 of file LevelSetCutUserObject.C.

29  : GeometricCutUserObject(parameters),
30  _level_set_var_number(_subproblem
31  .getVariable(_tid,
32  parameters.get<VariableName>("level_set_var"),
33  Moose::VarKindType::VAR_ANY,
34  Moose::VarFieldType::VAR_FIELD_STANDARD)
35  .number()),
36  _system(_subproblem.getSystem(getParam<VariableName>("level_set_var"))),
37  _solution(_system.current_local_solution.get())
38 {
39 }

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 42 of file LevelSetCutUserObject.C.

46 {
47  bool cut_elem = false;
48 
49  unsigned int n_sides = elem->n_sides();
50 
51  for (unsigned int i = 0; i < n_sides; ++i)
52  {
53  UniquePtr<const Elem> curr_side = elem->side_ptr(i);
54 
55  if (curr_side->type() != EDGE2)
56  mooseError("In LevelSetCutUserObject element side must be EDGE2, but type is: ",
57  libMesh::Utility::enum_to_string(curr_side->type()),
58  " base element type is: ",
59  libMesh::Utility::enum_to_string(elem->type()));
60 
61  const Node * node1 = curr_side->node_ptr(0);
62  const Node * node2 = curr_side->node_ptr(1);
63 
64  dof_id_type ls_dof_id_1 = node1->dof_number(_system.number(), _level_set_var_number, 0);
65  dof_id_type ls_dof_id_2 = node2->dof_number(_system.number(), _level_set_var_number, 0);
66 
67  Number ls_node_1 = (*_solution)(ls_dof_id_1);
68  Number ls_node_2 = (*_solution)(ls_dof_id_2);
69 
70  if (ls_node_1 * ls_node_2 < 0)
71  {
72  cut_elem = true;
73  Xfem::CutEdge mycut;
74  mycut._id1 = node1->id();
75  mycut._id2 = node2->id();
76  Real seg_int_frac = std::abs(ls_node_1) / std::abs(ls_node_1 - ls_node_2);
77  mycut._distance = seg_int_frac;
78  mycut._host_side_id = i;
79  cut_edges.push_back(mycut);
80  }
81  }
82 
83  return cut_elem;
84 }

◆ 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 87 of file LevelSetCutUserObject.C.

90 {
91  bool cut_elem = false;
92 
93  for (unsigned int i = 0; i < elem->n_sides(); ++i)
94  {
95  std::unique_ptr<const Elem> curr_side = elem->side_ptr(i);
96  if (curr_side->dim() != 2)
97  mooseError("In LevelSetCutUserObject dimension of side must be 2, but it is ",
98  curr_side->dim());
99  unsigned int n_edges = curr_side->n_sides();
100 
101  std::vector<unsigned int> cut_edges;
102  std::vector<Real> cut_pos;
103 
104  for (unsigned int j = 0; j < n_edges; j++)
105  {
106  // This returns the lowest-order type of side.
107  std::unique_ptr<const Elem> curr_edge = curr_side->side_ptr(j);
108  if (curr_edge->type() != EDGE2)
109  mooseError("In LevelSetCutUserObject face edge must be EDGE2, but type is: ",
110  libMesh::Utility::enum_to_string(curr_edge->type()),
111  " base element type is: ",
112  libMesh::Utility::enum_to_string(elem->type()));
113 
114  const Node * node1 = curr_edge->node_ptr(0);
115  const Node * node2 = curr_edge->node_ptr(1);
116 
117  dof_id_type ls_dof_id_1 = node1->dof_number(_system.number(), _level_set_var_number, 0);
118  dof_id_type ls_dof_id_2 = node2->dof_number(_system.number(), _level_set_var_number, 0);
119 
120  Number ls_node_1 = (*_solution)(ls_dof_id_1);
121  Number ls_node_2 = (*_solution)(ls_dof_id_2);
122 
123  if (ls_node_1 * ls_node_2 < 0)
124  {
125  Real seg_int_frac = std::abs(ls_node_1) / std::abs(ls_node_1 - ls_node_2);
126  cut_edges.push_back(j);
127  cut_pos.push_back(seg_int_frac);
128  }
129  }
130 
131  if (cut_edges.size() == 2)
132  {
133  cut_elem = true;
134  Xfem::CutFace mycut;
135  mycut._face_id = i;
136  mycut._face_edge.push_back(cut_edges[0]);
137  mycut._face_edge.push_back(cut_edges[1]);
138  mycut._position.push_back(cut_pos[0]);
139  mycut._position.push_back(cut_pos[1]);
140  cut_faces.push_back(mycut);
141  }
142  }
143  return cut_elem;
144 }

◆ 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 147 of file LevelSetCutUserObject.C.

150 {
151  return false;
152 }

◆ 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 155 of file LevelSetCutUserObject.C.

158 {
159  mooseError("cutFragmentByGeometry not yet implemented for 3d level set cutting");
160  return false;
161 }

◆ deserialize()

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

Definition at line 222 of file GeometricCutUserObject.C.

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 }

Referenced by GeometricCutUserObject::finalize().

◆ execute()

void GeometricCutUserObject::execute ( )
overridevirtualinherited

Reimplemented in MovingLineSegmentCutSetUserObject.

Definition at line 67 of file GeometricCutUserObject.C.

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  {
91  Xfem::GeomMarkedElemInfo2D gmei2d;
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  {
122  Xfem::GeomMarkedElemInfo3D gmei3d;
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 }

Referenced by MovingLineSegmentCutSetUserObject::execute().

◆ finalize()

void GeometricCutUserObject::finalize ( )
overridevirtualinherited

Reimplemented in MovingLineSegmentCutSetUserObject.

Definition at line 254 of file GeometricCutUserObject.C.

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 }

Referenced by MovingLineSegmentCutSetUserObject::finalize().

◆ getCrackFrontPoints()

const std::vector< Point > LevelSetCutUserObject::getCrackFrontPoints ( unsigned 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 164 of file LevelSetCutUserObject.C.

165 {
166  mooseError("getCrackFrontPoints() is not implemented for this object.");
167 }

◆ getInterfaceID()

unsigned int GeometricCutUserObject::getInterfaceID ( ) const
inlineinherited

Get the interface ID for this cutting object.

Returns
the interface ID

Definition at line 172 of file GeometricCutUserObject.h.

172 { return _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 }

◆ 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.

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 }

Referenced by GeometricCutUserObject::finalize().

◆ setInterfaceID()

void GeometricCutUserObject::setInterfaceID ( unsigned int  interface_id)
inlineinherited

Set the interface ID for this cutting object.

Parameters
theinterface ID

Definition at line 178 of file GeometricCutUserObject.h.

178 { _interface_id = interface_id; };

Referenced by XFEM::addGeometricCut().

◆ 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 185 of file GeometricCutUserObject.h.

185 { return _heal_always; };

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

◆ validParams()

InputParameters CrackFrontPointsProvider::validParams ( )
staticinherited

Definition at line 15 of file CrackFrontPointsProvider.C.

16 {
17  InputParameters params = ElementUserObject::validParams();
18  params.addClassDescription("Base class for a class that can provide a set of points along a "
19  "crack front. The virtual functions must be overridden by a derived "
20  "class to provide this functionality.");
21  return params;
22 }

Member Data Documentation

◆ _heal_always

bool GeometricCutUserObject::_heal_always
protectedinherited

Heal the mesh.

Definition at line 195 of file GeometricCutUserObject.h.

◆ _interface_id

unsigned int GeometricCutUserObject::_interface_id
protectedinherited

Associated interface id.

Definition at line 192 of file GeometricCutUserObject.h.

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

◆ _last_step_initialized

unsigned int GeometricCutUserObject::_last_step_initialized
protectedinherited

Time step information needed to advance a 3D crack only at the real beginning of a time step.

Definition at line 198 of file GeometricCutUserObject.h.

Referenced by MeshCut3DUserObject::initialize().

◆ _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 45 of file LevelSetCutUserObject.h.

Referenced by cutElementByGeometry().

◆ _marked_elems_2d

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

Containers with information about all 2D and 3D elements marked for cutting by this object.

Definition at line 201 of file GeometricCutUserObject.h.

Referenced by GeometricCutUserObject::deserialize(), GeometricCutUserObject::execute(), GeometricCutUserObject::finalize(), GeometricCutUserObject::initialize(), GeometricCutUserObject::serialize(), and GeometricCutUserObject::threadJoin().

◆ _marked_elems_3d

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

Definition at line 202 of file GeometricCutUserObject.h.

Referenced by GeometricCutUserObject::deserialize(), GeometricCutUserObject::execute(), GeometricCutUserObject::finalize(), GeometricCutUserObject::initialize(), GeometricCutUserObject::serialize(), and GeometricCutUserObject::threadJoin().

◆ _solution

const NumericVector<Number>* LevelSetCutUserObject::_solution
protected

the subproblem solution vector

Definition at line 51 of file LevelSetCutUserObject.h.

◆ _system

const System& LevelSetCutUserObject::_system
protected

system reference

Definition at line 48 of file LevelSetCutUserObject.h.

Referenced by cutElementByGeometry().

◆ _xfem

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

Pointer to the XFEM controller object.

Definition at line 185 of file GeometricCutUserObject.h.

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

The documentation for this class was generated from the following files:
GeometricCutUserObject::serialize
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...
Definition: GeometricCutUserObject.C:209
Xfem::CutEdge::_id1
unsigned int _id1
ID of the first node on the edge.
Definition: GeometricCutUserObject.h:29
EFAElement2D::isFinalCut
virtual bool isFinalCut() const
Definition: EFAElement2D.C:791
Xfem::GeomMarkedElemInfo2D
Data structure describing geometrically described cut through 2D element.
Definition: GeometricCutUserObject.h:75
EFAElement3D::isFinalCut
virtual bool isFinalCut() const
Definition: EFAElement3D.C:838
Xfem::CutEdge::_distance
Real _distance
Fractional distance along the edge (from node 1 to 2) where the cut is located.
Definition: GeometricCutUserObject.h:33
GeometricCutUserObject::_xfem
std::shared_ptr< XFEM > _xfem
Pointer to the XFEM controller object.
Definition: GeometricCutUserObject.h:185
LevelSetCutUserObject::_system
const System & _system
system reference
Definition: LevelSetCutUserObject.h:48
GeometricCutUserObject::deserialize
void deserialize(std::vector< std::string > &serialized_buffers)
Definition: GeometricCutUserObject.C:222
Xfem::CutFace::_position
std::vector< Real > _position
Fractional distance along the cut edges where the cut is located.
Definition: GeometricCutUserObject.h:71
Xfem::CutEdge::_id2
unsigned int _id2
ID of the second node on the edge.
Definition: GeometricCutUserObject.h:31
Xfem::GeomMarkedElemInfo2D::_elem_cut_edges
std::vector< CutEdge > _elem_cut_edges
Container for data about all cut edges in this element.
Definition: GeometricCutUserObject.h:78
Xfem::GeomMarkedElemInfo2D::_elem_cut_nodes
std::vector< CutNode > _elem_cut_nodes
Container for data about all cut nodes in this element.
Definition: GeometricCutUserObject.h:80
Xfem::CutEdge::_host_side_id
unsigned int _host_side_id
Local ID of this side in the host element.
Definition: GeometricCutUserObject.h:35
Xfem::GeomMarkedElemInfo2D::_frag_edges
std::vector< std::vector< Point > > _frag_edges
Container for data about all cut edges in cut fragments in this element.
Definition: GeometricCutUserObject.h:84
GeometricCutUserObject
Definition: GeometricCutUserObject.h:106
Xfem::CutFace::_face_id
unsigned int _face_id
ID of the cut face.
Definition: GeometricCutUserObject.h:67
EFAElement3D
Definition: EFAElement3D.h:20
Xfem::CutFace::_face_edge
std::vector< unsigned int > _face_edge
IDs of all cut faces.
Definition: GeometricCutUserObject.h:69
GeometricCutUserObject::_marked_elems_3d
std::map< unsigned int, std::vector< Xfem::GeomMarkedElemInfo3D > > _marked_elems_3d
Definition: GeometricCutUserObject.h:202
GeometricCutUserObject::cutFragmentByGeometry
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.
dataLoad
void dataLoad(std::istream &stream, Xfem::CutFace &cf, void *context)
Definition: GeometricCutUserObject.C:163
dataStore
void dataStore(std::ostream &stream, Xfem::CutFace &cf, void *context)
Definition: GeometricCutUserObject.C:154
Xfem::GeomMarkedElemInfo3D
Data structure describing geometrically described cut through 3D element.
Definition: GeometricCutUserObject.h:88
Xfem::GeomMarkedElemInfo2D::_frag_cut_edges
std::vector< CutEdge > _frag_cut_edges
Container for data about all cut fragments in this element.
Definition: GeometricCutUserObject.h:82
validParams
InputParameters validParams()
GeometricCutUserObject::_interface_id
unsigned int _interface_id
Associated interface id.
Definition: GeometricCutUserObject.h:192
GeometricCutUserObject::_marked_elems_2d
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.
Definition: GeometricCutUserObject.h:201
LevelSetCutUserObject::_level_set_var_number
const unsigned int _level_set_var_number
The variable number of the level set variable we using to define the cuts.
Definition: LevelSetCutUserObject.h:45
LevelSetCutUserObject::_solution
const NumericVector< Number > * _solution
the subproblem solution vector
Definition: LevelSetCutUserObject.h:51
GeometricCutUserObject::_heal_always
bool _heal_always
Heal the mesh.
Definition: GeometricCutUserObject.h:195
GeometricCutUserObject::cutElementByGeometry
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.
GeometricCutUserObject::GeometricCutUserObject
GeometricCutUserObject(const InputParameters &parameters)
Factory constructor, takes parameters so that all derived classes can be built using the same constru...
Definition: GeometricCutUserObject.C:39
Xfem::GeomMarkedElemInfo3D::_frag_faces
std::vector< std::vector< Point > > _frag_faces
Container for data about all cut faces in cut fragments in this element.
Definition: GeometricCutUserObject.h:95
Xfem::GeomMarkedElemInfo3D::_frag_cut_faces
std::vector< CutFace > _frag_cut_faces
Container for data about all faces this element's fragment.
Definition: GeometricCutUserObject.h:93
EFAElement2D::numFragments
virtual unsigned int numFragments() const
Definition: EFAElement2D.C:202
EFAElement2D
Definition: EFAElement2D.h:20
Xfem::CutFace
Data structure defining a cut through a face.
Definition: GeometricCutUserObject.h:64
Xfem::GeomMarkedElemInfo3D::_elem_cut_faces
std::vector< CutFace > _elem_cut_faces
Container for data about all cut faces in this element.
Definition: GeometricCutUserObject.h:91
Xfem::CutEdge
Data structure defining a cut on an element edge.
Definition: GeometricCutUserObject.h:26
Generated on Sat Jan 25 2020 12:05:06 for www.mooseframework.org by   doxygen 1.8.16