OpenCMISS-Zinc C++ API Documentation
 All Classes Namespaces Files Functions Typedefs Enumerations Enumerator Pages
element.hpp
Go to the documentation of this file.
1 
4 /* OpenCMISS-Zinc Library
5 *
6 * This Source Code Form is subject to the terms of the Mozilla Public
7 * License, v. 2.0. If a copy of the MPL was not distributed with this
8 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
9 
10 #ifndef CMZN_ELEMENT_HPP__
11 #define CMZN_ELEMENT_HPP__
12 
13 #include "opencmiss/zinc/element.h"
14 #include "opencmiss/zinc/field.hpp"
15 #include "opencmiss/zinc/differentialoperator.hpp"
16 #include "opencmiss/zinc/node.hpp"
17 
18 namespace OpenCMISS
19 {
20 namespace Zinc
21 {
22 
32 {
33 private:
34 
35  cmzn_elementbasis_id id;
36 
37 public:
38 
39  Elementbasis() : id(0)
40  { }
41 
42  // takes ownership of C handle, responsibility for destroying it
43  explicit Elementbasis(cmzn_elementbasis_id element_basis_id) :
44  id(element_basis_id)
45  { }
46 
47  Elementbasis(const Elementbasis& elementBasis) :
48  id(cmzn_elementbasis_access(elementBasis.id))
49  { }
50 
51  Elementbasis& operator=(const Elementbasis& elementBasis)
52  {
53  cmzn_elementbasis_id temp_id = cmzn_elementbasis_access(elementBasis.id);
54  if (0 != id)
55  {
56  cmzn_elementbasis_destroy(&id);
57  }
58  id = temp_id;
59  return *this;
60  }
61 
62  ~Elementbasis()
63  {
64  if (0 != id)
65  {
66  cmzn_elementbasis_destroy(&id);
67  }
68  }
69 
75  bool isValid() const
76  {
77  return (0 != id);
78  }
79 
86  {
87  FUNCTION_TYPE_INVALID = CMZN_ELEMENTBASIS_FUNCTION_TYPE_INVALID,
89  FUNCTION_TYPE_CONSTANT = CMZN_ELEMENTBASIS_FUNCTION_TYPE_CONSTANT,
91  FUNCTION_TYPE_LINEAR_LAGRANGE = CMZN_ELEMENTBASIS_FUNCTION_TYPE_LINEAR_LAGRANGE,
94  FUNCTION_TYPE_QUADRATIC_LAGRANGE = CMZN_ELEMENTBASIS_FUNCTION_TYPE_QUADRATIC_LAGRANGE,
97  FUNCTION_TYPE_CUBIC_LAGRANGE = CMZN_ELEMENTBASIS_FUNCTION_TYPE_CUBIC_LAGRANGE,
100  FUNCTION_TYPE_LINEAR_SIMPLEX = CMZN_ELEMENTBASIS_FUNCTION_TYPE_LINEAR_SIMPLEX,
107  FUNCTION_TYPE_QUADRATIC_SIMPLEX = CMZN_ELEMENTBASIS_FUNCTION_TYPE_QUADRATIC_SIMPLEX,
115  FUNCTION_TYPE_CUBIC_HERMITE = CMZN_ELEMENTBASIS_FUNCTION_TYPE_CUBIC_HERMITE
118  };
119 
125  cmzn_elementbasis_id getId() const
126  {
127  return id;
128  }
129 
136  {
137  return cmzn_elementbasis_get_dimension(id);
138  }
139 
147  enum FunctionType getFunctionType(int chartComponent)
148  {
149  return static_cast<FunctionType>(cmzn_elementbasis_get_function_type(id, chartComponent));
150  }
151 
160  int setFunctionType(int chartComponent, FunctionType functionType)
161  {
162  return cmzn_elementbasis_set_function_type(id, chartComponent,
163  static_cast<cmzn_elementbasis_function_type>(functionType));
164  }
165 
172  {
173  return cmzn_elementbasis_get_number_of_nodes(id);
174  }
175 
189  {
190  return cmzn_elementbasis_get_number_of_functions(id);
191  }
192 
201  int getNumberOfFunctionsPerNode(int nodeNumber)
202  {
203  return cmzn_elementbasis_get_number_of_functions_per_node(id, nodeNumber);
204  }
205 
206 };
207 
208 class Fieldmodule;
209 class Mesh;
210 class MeshGroup;
211 class Elementtemplate;
212 
219 class Element
220 {
221 private:
222 
223  cmzn_element_id id;
224 
225 public:
226 
227  Element() : id(0)
228  { }
229 
230  // takes ownership of C handle, responsibility for destroying it
231  explicit Element(cmzn_element_id element_id) :
232  id(element_id)
233  { }
234 
235  Element(const Element& element) :
236  id(cmzn_element_access(element.id))
237  { }
238 
239  ~Element()
240  {
241  if (0 != id)
242  {
243  cmzn_element_destroy(&id);
244  }
245  }
246 
252  bool isValid() const
253  {
254  return (0 != id);
255  }
256 
261  {
262  CHANGE_FLAG_NONE = CMZN_ELEMENT_CHANGE_FLAG_NONE,
264  CHANGE_FLAG_ADD = CMZN_ELEMENT_CHANGE_FLAG_ADD,
266  CHANGE_FLAG_REMOVE = CMZN_ELEMENT_CHANGE_FLAG_REMOVE,
268  CHANGE_FLAG_IDENTIFIER = CMZN_ELEMENT_CHANGE_FLAG_IDENTIFIER,
270  CHANGE_FLAG_DEFINITION = CMZN_ELEMENT_CHANGE_FLAG_DEFINITION,
272  CHANGE_FLAG_FIELD = CMZN_ELEMENT_CHANGE_FLAG_FIELD
274  };
275 
279  typedef int ChangeFlags;
280 
284  enum FaceType
285  {
286  FACE_TYPE_INVALID = CMZN_ELEMENT_FACE_TYPE_INVALID,
288  FACE_TYPE_ALL = CMZN_ELEMENT_FACE_TYPE_ALL,
290  FACE_TYPE_ANY_FACE = CMZN_ELEMENT_FACE_TYPE_ANY_FACE,
292  FACE_TYPE_NO_FACE = CMZN_ELEMENT_FACE_TYPE_NO_FACE,
294  FACE_TYPE_XI1_0 = CMZN_ELEMENT_FACE_TYPE_XI1_0,
296  FACE_TYPE_XI1_1 = CMZN_ELEMENT_FACE_TYPE_XI1_1,
298  FACE_TYPE_XI2_0 = CMZN_ELEMENT_FACE_TYPE_XI2_0,
300  FACE_TYPE_XI2_1 = CMZN_ELEMENT_FACE_TYPE_XI2_1,
302  FACE_TYPE_XI3_0 = CMZN_ELEMENT_FACE_TYPE_XI3_0,
304  FACE_TYPE_XI3_1 = CMZN_ELEMENT_FACE_TYPE_XI3_1
306  };
307 
308  Element& operator=(const Element& element)
309  {
310  cmzn_element_id temp_id = cmzn_element_access(element.id);
311  if (0 != id)
312  {
313  cmzn_element_destroy(&id);
314  }
315  id = temp_id;
316  return *this;
317  }
318 
323  {
324  SHAPE_TYPE_INVALID = CMZN_ELEMENT_SHAPE_TYPE_INVALID,
326  SHAPE_TYPE_LINE = CMZN_ELEMENT_SHAPE_TYPE_LINE,
328  SHAPE_TYPE_SQUARE = CMZN_ELEMENT_SHAPE_TYPE_SQUARE,
330  SHAPE_TYPE_TRIANGLE = CMZN_ELEMENT_SHAPE_TYPE_TRIANGLE,
332  SHAPE_TYPE_CUBE = CMZN_ELEMENT_SHAPE_TYPE_CUBE,
334  SHAPE_TYPE_TETRAHEDRON = CMZN_ELEMENT_SHAPE_TYPE_TETRAHEDRON,
336  SHAPE_TYPE_WEDGE12 = CMZN_ELEMENT_SHAPE_TYPE_WEDGE12,
338  SHAPE_TYPE_WEDGE13 = CMZN_ELEMENT_SHAPE_TYPE_WEDGE13,
340  SHAPE_TYPE_WEDGE23 = CMZN_ELEMENT_SHAPE_TYPE_WEDGE23
342  };
343 
348  {
349  POINT_SAMPLING_MODE_INVALID = CMZN_ELEMENT_POINT_SAMPLING_MODE_INVALID,
351  POINT_SAMPLING_MODE_CELL_CENTRES = CMZN_ELEMENT_POINT_SAMPLING_MODE_CELL_CENTRES,
353  POINT_SAMPLING_MODE_CELL_CORNERS = CMZN_ELEMENT_POINT_SAMPLING_MODE_CELL_CORNERS,
355  POINT_SAMPLING_MODE_CELL_POISSON = CMZN_ELEMENT_POINT_SAMPLING_MODE_CELL_POISSON,
360  POINT_SAMPLING_MODE_SET_LOCATION = CMZN_ELEMENT_POINT_SAMPLING_MODE_SET_LOCATION,
362  POINT_SAMPLING_MODE_GAUSSIAN_QUADRATURE = CMZN_ELEMENT_POINT_SAMPLING_MODE_GAUSSIAN_QUADRATURE
367  };
368 
373  {
374  QUADRATURE_RULE_INVALID = CMZN_ELEMENT_QUADRATURE_RULE_INVALID,
376  QUADRATURE_RULE_GAUSSIAN = CMZN_ELEMENT_QUADRATURE_RULE_GAUSSIAN,
382  QUADRATURE_RULE_MIDPOINT = CMZN_ELEMENT_QUADRATURE_RULE_MIDPOINT
385  };
386 
392  cmzn_element_id getId() const
393  {
394  return id;
395  }
396 
403  {
404  return cmzn_element_get_dimension(id);
405  }
406 
415  {
416  return cmzn_element_get_identifier(id);
417  }
418 
427  int setIdentifier(int identifier)
428  {
429  return cmzn_element_set_identifier(id, identifier);
430  }
431 
437  inline Mesh getMesh() const;
438 
448  {
449  return static_cast<ShapeType>(cmzn_element_get_shape_type(id));
450  }
451 
459  inline int merge(const Elementtemplate& elementTemplate);
460 
461 };
462 
463 inline bool operator==(const Element& a, const Element& b)
464 {
465  return a.getId() == b.getId();
466 }
467 
476 {
477 private:
478 
479  cmzn_elementtemplate_id id;
480 
481 public:
482 
483  Elementtemplate() : id(0)
484  { }
485 
486  // takes ownership of C handle, responsibility for destroying it
487  explicit Elementtemplate(cmzn_elementtemplate_id element_template_id) :
488  id(element_template_id)
489  { }
490 
491  Elementtemplate(const Elementtemplate& elementTemplate) :
492  id(cmzn_elementtemplate_access(elementTemplate.id))
493  { }
494 
495  Elementtemplate& operator=(const Elementtemplate& elementTemplate)
496  {
497  cmzn_elementtemplate_id temp_id = cmzn_elementtemplate_access(elementTemplate.id);
498  if (0 != id)
499  {
500  cmzn_elementtemplate_destroy(&id);
501  }
502  id = temp_id;
503  return *this;
504  }
505 
506  ~Elementtemplate()
507  {
508  if (0 != id)
509  {
510  cmzn_elementtemplate_destroy(&id);
511  }
512  }
513 
519  bool isValid() const
520  {
521  return (0 != id);
522  }
523 
529  cmzn_elementtemplate_id getId() const
530  {
531  return id;
532  }
533 
540  {
541  return static_cast<Element::ShapeType>(cmzn_elementtemplate_get_element_shape_type(id));
542  }
543 
558  {
559  return cmzn_elementtemplate_set_element_shape_type(id,
560  static_cast<cmzn_element_shape_type>(shapeType));
561  }
562 
569  {
570  return cmzn_elementtemplate_get_number_of_nodes(id);
571  }
572 
581  int setNumberOfNodes(int numberOfNodes)
582  {
583  return cmzn_elementtemplate_set_number_of_nodes(id, numberOfNodes);
584  }
585 
596  int defineFieldElementConstant(const Field& field, int componentNumber)
597  {
598  return cmzn_elementtemplate_define_field_element_constant(
599  id, field.getId(), componentNumber);
600  }
601 
628  int defineFieldSimpleNodal(const Field& field, int componentNumber,
629  const Elementbasis& basis, int nodeIndexesCount, const int *nodeIndexesIn)
630  {
631  return cmzn_elementtemplate_define_field_simple_nodal(
632  id, field.getId(), componentNumber, basis.getId(),
633  nodeIndexesCount, nodeIndexesIn);
634  }
635 
655  int setMapNodeValueLabel(const Field& field, int componentNumber,
656  int basisNodeIndex, int nodeFunctionIndex, Node::ValueLabel nodeValueLabel)
657  {
658  return cmzn_elementtemplate_set_map_node_value_label(id, field.getId(),
659  componentNumber, basisNodeIndex, nodeFunctionIndex,
660  static_cast<cmzn_node_value_label>(nodeValueLabel));
661  }
662 
682  int setMapNodeVersion(const Field& field, int componentNumber,
683  int basisNodeIndex, int nodeFunctionIndex, int versionNumber)
684  {
685  return cmzn_elementtemplate_set_map_node_version(id, field.getId(),
686  componentNumber, basisNodeIndex, nodeFunctionIndex, versionNumber);
687  }
688 
697  Node getNode(int localNodeIndex)
698  {
699  return Node(cmzn_elementtemplate_get_node(id, localNodeIndex));
700  }
701 
711  int setNode(int localNodeIndex, const Node& node)
712  {
713  return cmzn_elementtemplate_set_node(id, localNodeIndex, node.getId());
714  }
715 };
716 
723 {
724 private:
725 
726  cmzn_elementiterator_id id;
727 
728 public:
729 
730  Elementiterator() : id(0)
731  { }
732 
733  // takes ownership of C handle, responsibility for destroying it
734  explicit Elementiterator(cmzn_elementiterator_id element_iterator_id) :
735  id(element_iterator_id)
736  { }
737 
738  Elementiterator(const Elementiterator& elementIterator) :
739  id(cmzn_elementiterator_access(elementIterator.id))
740  { }
741 
742  Elementiterator& operator=(const Elementiterator& elementIterator)
743  {
744  cmzn_elementiterator_id temp_id = cmzn_elementiterator_access(elementIterator.id);
745  if (0 != id)
746  {
747  cmzn_elementiterator_destroy(&id);
748  }
749  id = temp_id;
750  return *this;
751  }
752 
753  ~Elementiterator()
754  {
755  if (0 != id)
756  {
757  cmzn_elementiterator_destroy(&id);
758  }
759  }
760 
766  bool isValid() const
767  {
768  return (0 != id);
769  }
770 
779  {
780  return Element(cmzn_elementiterator_next(id));
781  }
782 };
783 
791 class Mesh
792 {
793 
794 protected:
795  cmzn_mesh_id id;
796 
797 public:
798 
799  Mesh() : id(0)
800  { }
801 
802  // takes ownership of C handle, responsibility for destroying it
803  explicit Mesh(cmzn_mesh_id mesh_id) : id(mesh_id)
804  { }
805 
806  Mesh(const Mesh& mesh) :
807  id(cmzn_mesh_access(mesh.id))
808  { }
809 
810  ~Mesh()
811  {
812  if (0 != id)
813  {
814  cmzn_mesh_destroy(&id);
815  }
816  }
817 
823  bool isValid() const
824  {
825  return (0 != id);
826  }
827 
828  Mesh& operator=(const Mesh& mesh)
829  {
830  cmzn_mesh_id temp_id = cmzn_mesh_access(mesh.id);
831  if (0 != id)
832  {
833  cmzn_mesh_destroy(&id);
834  }
835  id = temp_id;
836  return *this;
837  }
838 
844  cmzn_mesh_id getId() const
845  {
846  return id;
847  }
848 
856  inline MeshGroup castGroup();
857 
864  bool containsElement(const Element& element)
865  {
866  return cmzn_mesh_contains_element(id, element.getId());
867  }
868 
876  {
877  return Elementtemplate(cmzn_mesh_create_elementtemplate(id));
878  }
879 
891  Element createElement(int identifier, const Elementtemplate& elementTemplate)
892  {
893  return Element(cmzn_mesh_create_element(id, identifier, elementTemplate.getId()));
894  }
895 
909  {
910  return Elementiterator(cmzn_mesh_create_elementiterator(id));
911  }
912 
924  int defineElement(int identifier, const Elementtemplate& elementTemplate)
925  {
926  return cmzn_mesh_define_element(id, identifier, elementTemplate.getId());
927  }
928 
936  {
937  return cmzn_mesh_destroy_all_elements(id);
938  }
939 
948  int destroyElement(const Element& element)
949  {
950  return cmzn_mesh_destroy_element(id, element.getId());
951  }
952 
964  int destroyElementsConditional(const Field& conditionalField)
965  {
966  return cmzn_mesh_destroy_elements_conditional(id,
967  conditionalField.getId());
968  }
969 
977  {
978  return Element(cmzn_mesh_find_element_by_identifier(id, identifier));
979  }
980 
993  {
994  return Differentialoperator(cmzn_mesh_get_chart_differentialoperator(
995  id, order, term));
996  }
997 
1004  {
1005  return cmzn_mesh_get_dimension(id);
1006  }
1007 
1013  inline Fieldmodule getFieldmodule() const;
1014 
1022  {
1023  return Mesh(cmzn_mesh_get_master_mesh(id));
1024  }
1025 
1033  char *getName()
1034  {
1035  return cmzn_mesh_get_name(id);
1036  }
1037 
1043  int getSize()
1044  {
1045  return cmzn_mesh_get_size(id);
1046  }
1047 
1048 };
1049 
1050 inline bool operator==(const Mesh& a, const Mesh& b)
1051 {
1052  return cmzn_mesh_match(a.getId(), b.getId());
1053 }
1054 
1055 inline Mesh Element::getMesh() const
1056 {
1057  return Mesh(cmzn_element_get_mesh(id));
1058 }
1059 
1065 class MeshGroup : public Mesh
1066 {
1067 
1068 public:
1069 
1070  // takes ownership of C handle, responsibility for destroying it
1071  explicit MeshGroup(cmzn_mesh_group_id mesh_id) : Mesh(reinterpret_cast<cmzn_mesh_id>(mesh_id))
1072  { }
1073 
1074  MeshGroup()
1075  { }
1076 
1082  cmzn_mesh_group_id getId() const
1083  {
1084  return (cmzn_mesh_group_id)(id);
1085  }
1086 
1095  int addElement(const Element& element)
1096  {
1097  return cmzn_mesh_group_add_element(
1098  reinterpret_cast<cmzn_mesh_group_id>(id), element.getId());
1099  }
1100 
1111  int addElementsConditional(const Field& conditionalField)
1112  {
1113  return cmzn_mesh_group_add_elements_conditional(
1114  reinterpret_cast<cmzn_mesh_group_id>(id), conditionalField.getId());
1115  }
1116 
1123  {
1124  return cmzn_mesh_group_remove_all_elements(reinterpret_cast<cmzn_mesh_group_id>(id));
1125  }
1126 
1135  int removeElement(const Element& element)
1136  {
1137  return cmzn_mesh_group_remove_element(reinterpret_cast<cmzn_mesh_group_id>(id),
1138  element.getId());
1139  }
1140 
1151  int removeElementsConditional(const Field& conditionalField)
1152  {
1153  return cmzn_mesh_group_remove_elements_conditional(
1154  reinterpret_cast<cmzn_mesh_group_id>(id), conditionalField.getId());
1155  }
1156 
1157 };
1158 
1160 {
1161  return MeshGroup(cmzn_mesh_cast_group(id));
1162 }
1163 
1170 {
1171 private:
1172 
1173  cmzn_meshchanges_id id;
1174 
1175 public:
1176 
1177  Meshchanges() : id(0)
1178  { }
1179 
1180  // takes ownership of C handle, responsibility for destroying it
1181  explicit Meshchanges(cmzn_meshchanges_id meshchanges_id) :
1182  id(meshchanges_id)
1183  { }
1184 
1185  Meshchanges(const Meshchanges& meshchanges) :
1186  id(cmzn_meshchanges_access(meshchanges.id))
1187  { }
1188 
1189  Meshchanges& operator=(const Meshchanges& meshchanges)
1190  {
1191  cmzn_meshchanges_id temp_id = cmzn_meshchanges_access(meshchanges.id);
1192  if (0 != id)
1193  cmzn_meshchanges_destroy(&id);
1194  id = temp_id;
1195  return *this;
1196  }
1197 
1198  ~Meshchanges()
1199  {
1200  if (0 != id)
1201  cmzn_meshchanges_destroy(&id);
1202  }
1203 
1209  bool isValid() const
1210  {
1211  return (0 != id);
1212  }
1213 
1224  {
1225  return cmzn_meshchanges_get_element_change_flags(id, element.getId());
1226  }
1227 
1235  {
1236  return cmzn_meshchanges_get_number_of_changes(id);
1237  }
1238 
1245  {
1246  return cmzn_meshchanges_get_summary_element_change_flags(id);
1247  }
1248 };
1249 
1250 inline int Element::merge(const Elementtemplate& elementTemplate)
1251 {
1252  return cmzn_element_merge(id, elementTemplate.getId());
1253 }
1254 
1255 } // namespace Zinc
1256 }
1257 
1258 #endif /* CMZN_ELEMENT_HPP__ */
Definition: element.hpp:288
int addElement(const Element &element)
Definition: element.hpp:1095
A single finite element from a mesh.
Definition: element.hpp:219
int setElementShapeType(enum Element::ShapeType shapeType)
Definition: element.hpp:557
int addElementsConditional(const Field &conditionalField)
Definition: element.hpp:1111
int destroyAllElements()
Definition: element.hpp:935
ValueLabel
Definition: node.hpp:84
int defineElement(int identifier, const Elementtemplate &elementTemplate)
Definition: element.hpp:924
A set of basis functions that can apply over an element of a given dimension.
Definition: element.hpp:31
Elementtemplate createElementtemplate()
Definition: element.hpp:875
Base field type: an abstraction of a mathematical field.
Definition: field.hpp:50
bool isValid() const
Definition: element.hpp:766
ShapeType
Definition: element.hpp:322
Differentialoperator getChartDifferentialoperator(int order, int term)
Definition: element.hpp:992
int removeAllElements()
Definition: element.hpp:1122
int getDimension()
Definition: element.hpp:135
Mesh getMesh() const
Definition: element.hpp:1055
int getNumberOfFunctions()
Definition: element.hpp:188
int setNumberOfNodes(int numberOfNodes)
Definition: element.hpp:581
cmzn_mesh_group_id getId() const
Definition: element.hpp:1082
int getNumberOfFunctionsPerNode(int nodeNumber)
Definition: element.hpp:201
int ChangeFlags
Definition: element.hpp:279
Describes the derivative of a field to evaluate.
Definition: differentialoperator.hpp:26
Node getNode(int localNodeIndex)
Definition: element.hpp:697
int setMapNodeVersion(const Field &field, int componentNumber, int basisNodeIndex, int nodeFunctionIndex, int versionNumber)
Definition: element.hpp:682
bool isValid() const
Definition: element.hpp:252
Element::ChangeFlags getElementChangeFlags(const Element &element)
Definition: element.hpp:1223
bool isValid() const
Definition: element.hpp:519
int defineFieldSimpleNodal(const Field &field, int componentNumber, const Elementbasis &basis, int nodeIndexesCount, const int *nodeIndexesIn)
Definition: element.hpp:628
QuadratureRule
Definition: element.hpp:372
int removeElement(const Element &element)
Definition: element.hpp:1135
cmzn_field_id getId() const
Definition: field.hpp:102
An iterator for looping through all the elements in a mesh.
Definition: element.hpp:722
MeshGroup castGroup()
Definition: element.hpp:1159
Element findElementByIdentifier(int identifier)
Definition: element.hpp:976
A description of element shape and field definitions.
Definition: element.hpp:475
int getDimension()
Definition: element.hpp:402
FunctionType
Definition: element.hpp:85
cmzn_element_id getId() const
Definition: element.hpp:392
ChangeFlag
Definition: element.hpp:260
enum FunctionType getFunctionType(int chartComponent)
Definition: element.hpp:147
cmzn_mesh_id getId() const
Definition: element.hpp:844
bool containsElement(const Element &element)
Definition: element.hpp:864
bool isValid() const
Definition: element.hpp:1209
int getSize()
Definition: element.hpp:1043
int defineFieldElementConstant(const Field &field, int componentNumber)
Definition: element.hpp:596
bool isValid() const
Definition: element.hpp:823
cmzn_node_id getId() const
Definition: node.hpp:140
A subset of a master mesh.
Definition: element.hpp:1065
char * getName()
Definition: element.hpp:1033
int destroyElementsConditional(const Field &conditionalField)
Definition: element.hpp:964
Container/manager of fields and domains within a region.
Definition: fieldmodule.hpp:134
int destroyElement(const Element &element)
Definition: element.hpp:948
int getNumberOfChanges()
Definition: element.hpp:1234
int getNumberOfNodes()
Definition: element.hpp:568
Mesh getMasterMesh()
Definition: element.hpp:1021
cmzn_elementbasis_id getId() const
Definition: element.hpp:125
Element::ChangeFlags getSummaryElementChangeFlags()
Definition: element.hpp:1244
cmzn_elementtemplate_id getId() const
Definition: element.hpp:529
PointSamplingMode
Definition: element.hpp:347
int getNumberOfNodes()
Definition: element.hpp:171
int setNode(int localNodeIndex, const Node &node)
Definition: element.hpp:711
Element next()
Definition: element.hpp:778
enum Element::ShapeType getElementShapeType()
Definition: element.hpp:539
enum ShapeType getShapeType()
Definition: element.hpp:447
int removeElementsConditional(const Field &conditionalField)
Definition: element.hpp:1151
int setMapNodeValueLabel(const Field &field, int componentNumber, int basisNodeIndex, int nodeFunctionIndex, Node::ValueLabel nodeValueLabel)
Definition: element.hpp:655
Elementiterator createElementiterator()
Definition: element.hpp:908
Point object used to represent finite element nodes.
Definition: node.hpp:38
int merge(const Elementtemplate &elementTemplate)
Definition: element.hpp:1250
int setIdentifier(int identifier)
Definition: element.hpp:427
int getIdentifier()
Definition: element.hpp:414
bool isValid() const
Definition: element.hpp:75
FaceType
Definition: element.hpp:284
Element createElement(int identifier, const Elementtemplate &elementTemplate)
Definition: element.hpp:891
A finite element mesh consisting of a set of elements of fixed dimension.
Definition: element.hpp:791
int getDimension()
Definition: element.hpp:1003
Fieldmodule getFieldmodule() const
Definition: fieldmodule.hpp:1779
Object describing changes to a mesh in a fieldmoduleevent.
Definition: element.hpp:1169
int setFunctionType(int chartComponent, FunctionType functionType)
Definition: element.hpp:160