v0.8.13
Static Public Member Functions | List of all members
MoFEM::DefaultElementAdjacency Struct Reference

default adjacency map More...

#include <src/multi_indices/FEMultiIndices.hpp>

Static Public Member Functions

static MoFEMErrorCode defaultVertex (Interface &moab, const Field &field_ptr, const EntFiniteElement &fe_ptr, Range &adjacency)
 
static MoFEMErrorCode defaultEdge (Interface &moab, const Field &field_ptr, const EntFiniteElement &fe_ptr, Range &adjacency)
 
static MoFEMErrorCode defaultTri (Interface &moab, const Field &field_ptr, const EntFiniteElement &fe_ptr, Range &adjacency)
 
static MoFEMErrorCode defaultTet (Interface &moab, const Field &field_ptr, const EntFiniteElement &fe_ptr, Range &adjacency)
 
static MoFEMErrorCode defaultPrism (Interface &moab, const Field &field_ptr, const EntFiniteElement &fe_ptr, Range &adjacency)
 
static MoFEMErrorCode defaultMeshset (Interface &moab, const Field &field_ptr, const EntFiniteElement &fe_ptr, Range &adjacency)
 

Detailed Description

default adjacency map

Definition at line 357 of file FEMultiIndices.hpp.

Member Function Documentation

◆ defaultEdge()

MoFEMErrorCode MoFEM::DefaultElementAdjacency::defaultEdge ( Interface moab,
const Field field_ptr,
const EntFiniteElement fe_ptr,
Range &  adjacency 
)
static

Definition at line 556 of file FEMultiIndices.cpp.

558  {
560  EntityHandle fe_ent = fe_ptr.getEnt();
561  // Range nodes;
562  switch (field_ptr.getSpace()) {
563  case H1:
564  CHKERR moab.get_connectivity(&fe_ent, 1, adjacency, true);
565  // //moab.get_connectivity(&fe_ent,1,nodes,true);
566  // //use get adjacencies, this will allow take in account adjacencies set user
567  // CHKERR moab.get_adjacencies(&fe_ent,1,0,false,nodes,moab::Interface::UNION);
568  // {
569  // Range topo_nodes;
570  // CHKERR moab.get_connectivity(&fe_ent,1,topo_nodes,true);
571  // Range mid_nodes;
572  // CHKERR moab.get_connectivity(&fe_ent,1,mid_nodes,false);
573  // mid_nodes = subtract(mid_nodes,topo_nodes);
574  // nodes = subtract(nodes,mid_nodes);
575  // }
576  // adjacency.insert(nodes.begin(),nodes.end());
577  // adjacency.insert(fe_ent);
578  // break;
579  case L2:
580  case HCURL:
581  adjacency.insert(fe_ent);
582  break;
583  case NOFIELD: {
584  Range ents;
585  CHKERR moab.get_entities_by_handle(field_ptr.getMeshset(), ents, false);
586  adjacency.merge(ents);
587  for (auto e : ents) {
588  const_cast<SideNumber_multiIndex &>(fe_ptr.getSideNumberTable())
589  .insert(boost::shared_ptr<SideNumber>(new SideNumber(e, -1, 0, 0)));
590  }
591  } break;
592  default:
593  SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
594  "this field is not implemented for EDGE finite element");
595  }
596  // build side table
597  for (auto e : adjacency)
598  fe_ptr.getSideNumberPtr(e);
600 }
scalar or vector of scalars describe (no true field)
Definition: definitions.h:178
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return() ...
Definition: definitions.h:495
multi_index_container< boost::shared_ptr< SideNumber >, indexed_by< hashed_unique< member< SideNumber, EntityHandle, &SideNumber::ent > >, ordered_non_unique< composite_key< SideNumber, const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType >, member< SideNumber, char, &SideNumber::side_number > > >, ordered_non_unique< const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType > > > > SideNumber_multiIndex
SideNumber_multiIndex for SideNumber.
field with continuous tangents
Definition: definitions.h:180
#define CHKERR
Inline error check.
Definition: definitions.h:614
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:439
continuous field
Definition: definitions.h:179
field with C-1 continuity
Definition: definitions.h:182

◆ defaultMeshset()

MoFEMErrorCode MoFEM::DefaultElementAdjacency::defaultMeshset ( Interface moab,
const Field field_ptr,
const EntFiniteElement fe_ptr,
Range &  adjacency 
)
static

Definition at line 883 of file FEMultiIndices.cpp.

885  {
887  ErrorCode rval;
888  EntityHandle fe_ent = fe_ptr.getEnt();
889  // get all meshsets in finite element meshset
890  Range ent_ents_meshset;
891  rval =
892  moab.get_entities_by_type(fe_ent, MBENTITYSET, ent_ents_meshset, false);
894  // resolve recursively all ents in the meshset
895  Range ent_ents;
896  rval = moab.get_entities_by_handle(fe_ent, ent_ents, true);
898  switch (field_ptr.getSpace()) {
899  case H1:
900  adjacency.merge(ent_ents.subset_by_type(MBVERTEX));
901  case HCURL:
902  adjacency.merge(ent_ents.subset_by_type(MBEDGE));
903  case HDIV:
904  adjacency.merge(ent_ents.subset_by_type(MBTRI));
905  case L2:
906  adjacency.merge(ent_ents.subset_by_type(MBTET));
907  break;
908  case NOFIELD: {
909  Range ents;
910  rval = moab.get_entities_by_handle(field_ptr.getMeshset(), ents, false);
912  adjacency.merge(ents);
913  for (Range::iterator eit = ents.begin(); eit != ents.end(); eit++) {
914  const_cast<SideNumber_multiIndex &>(fe_ptr.getSideNumberTable())
915  .insert(
916  boost::shared_ptr<SideNumber>(new SideNumber(*eit, -1, 0, 0)));
917  }
918  } break;
919  default:
920  SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
921  }
923 }
#define CHKERRQ_MOAB(a)
check error code of MoAB function
Definition: definitions.h:533
field with continuous normal traction
Definition: definitions.h:181
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:519
scalar or vector of scalars describe (no true field)
Definition: definitions.h:178
multi_index_container< boost::shared_ptr< SideNumber >, indexed_by< hashed_unique< member< SideNumber, EntityHandle, &SideNumber::ent > >, ordered_non_unique< composite_key< SideNumber, const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType >, member< SideNumber, char, &SideNumber::side_number > > >, ordered_non_unique< const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType > > > > SideNumber_multiIndex
SideNumber_multiIndex for SideNumber.
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return() ...
Definition: definitions.h:526
static MoFEMErrorCodeGeneric< moab::ErrorCode > rval
Definition: Common.hpp:78
field with continuous tangents
Definition: definitions.h:180
continuous field
Definition: definitions.h:179
field with C-1 continuity
Definition: definitions.h:182

◆ defaultPrism()

MoFEMErrorCode MoFEM::DefaultElementAdjacency::defaultPrism ( Interface moab,
const Field field_ptr,
const EntFiniteElement fe_ptr,
Range &  adjacency 
)
static

Definition at line 733 of file FEMultiIndices.cpp.

735  {
737  ErrorCode rval;
738  EntityHandle fe_ent = fe_ptr.getEnt();
739  Range nodes;
740  // initialize side sets
741  try {
742  EntityHandle prism = fe_ent;
743  EntityHandle face_side3, face_side4;
744  rval = moab.side_element(prism, 2, 3, face_side3);
746  rval = moab.side_element(prism, 2, 4, face_side4);
748  fe_ptr.getRefElement()->getSideNumberPtr(face_side3);
749  fe_ptr.getRefElement()->getSideNumberPtr(face_side4);
750  for (int qq = 0; qq < 3; qq++) {
751  EntityHandle quad = 0;
752  rval = moab.side_element(prism, 2, qq, quad);
753  if (rval != MB_SUCCESS || quad == 0)
754  continue;
755  int side_number, sense, offset;
756  rval = moab.side_number(prism, quad, side_number, sense, offset);
757  if (side_number == -1 || rval != MB_SUCCESS)
758  continue;
759  const_cast<SideNumber_multiIndex &>(fe_ptr.getSideNumberTable())
760  .insert(boost::shared_ptr<SideNumber>(
761  new SideNumber(quad, side_number, sense, offset)));
762  }
763  int ee = 0;
764  for (; ee < 3; ee++) {
765  EntityHandle edge = 0;
766  rval = moab.side_element(prism, 1, ee, edge);
768  boost::shared_ptr<SideNumber> side_ptr =
769  fe_ptr.getRefElement()->getSideNumberPtr(edge);
770  if (side_ptr->side_number != ee) {
771  SETERRQ1(PETSC_COMM_SELF, 1, "data insistency for edge %d", ee);
772  }
773  rval = moab.side_element(prism, 1, 6 + ee, edge);
775  side_ptr = fe_ptr.getRefElement()->getSideNumberPtr(edge);
776  if (side_ptr->side_number != ee + 6) {
777  if (side_ptr->side_number != ee) {
778  SETERRQ1(PETSC_COMM_SELF, 1, "data insistency for edge %d", ee);
779  } else {
780  side_ptr->brother_side_number = ee + 6;
781  }
782  }
783  }
784  for (; ee < 6; ee++) {
785  EntityHandle edge = 0;
786  rval = moab.side_element(prism, 1, ee, edge);
787  if (rval != MB_SUCCESS || edge == 0)
788  continue;
789  int side_number, sense, offset;
790  rval = moab.side_number(prism, edge, side_number, sense, offset);
791  if (side_number == -1 || rval != MB_SUCCESS)
792  continue;
793  const_cast<SideNumber_multiIndex &>(fe_ptr.getSideNumberTable())
794  .insert(boost::shared_ptr<SideNumber>(
795  new SideNumber(edge, side_number, sense, offset)));
796  }
797  int nn = 0;
798  for (; nn < 3; nn++) {
799  EntityHandle node;
800  rval = moab.side_element(prism, 0, nn, node);
802  boost::shared_ptr<SideNumber> side_ptr =
803  fe_ptr.getRefElement()->getSideNumberPtr(node);
804  if (side_ptr->side_number != nn) {
805  SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
806  "data insistency for node %d", nn);
807  }
808  rval = moab.side_element(prism, 0, nn + 3, node);
810  side_ptr = fe_ptr.getRefElement()->getSideNumberPtr(node);
811  if (side_ptr->side_number != nn + 3) {
812  if (side_ptr->side_number != nn) {
813  SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
814  "data insistency for node %d", nn);
815  } else {
816  side_ptr->brother_side_number = nn + 3;
817  }
818  }
819  }
820  } catch (MoFEMException const &e) {
821  SETERRQ(PETSC_COMM_SELF, e.errorCode, e.errorMessage);
822  }
823  // get adjacencies
824  SideNumber_multiIndex &side_table =
825  fe_ptr.getRefElement()->getSideNumberTable();
826  switch (field_ptr.getSpace()) {
827  case H1:
828  // moab.get_connectivity(&fe_ent,1,nodes,true);
829  // use get adjacencies, this will allow take in account adjacencies set user
830  rval = moab.get_adjacencies(&fe_ent, 1, 0, false, nodes,
831  moab::Interface::UNION);
833  {
834  Range topo_nodes;
835  rval = moab.get_connectivity(&fe_ent, 1, topo_nodes, true);
837  Range mid_nodes;
838  rval = moab.get_connectivity(&fe_ent, 1, mid_nodes, false);
840  mid_nodes = subtract(mid_nodes, topo_nodes);
841  nodes = subtract(nodes, mid_nodes);
842  }
843  adjacency.insert(nodes.begin(), nodes.end());
844  case HCURL: {
845  SideNumber_multiIndex::nth_index<2>::type::iterator siit, hi_siit;
846  siit = side_table.get<2>().lower_bound(MBEDGE);
847  hi_siit = side_table.get<2>().upper_bound(MBEDGE);
848  for (; siit != hi_siit; siit++)
849  adjacency.insert(siit->get()->ent);
850  }
851  case HDIV: {
852  SideNumber_multiIndex::nth_index<2>::type::iterator siit, hi_siit;
853  siit = side_table.get<2>().lower_bound(MBTRI);
854  hi_siit = side_table.get<2>().upper_bound(MBTRI);
855  for (; siit != hi_siit; siit++)
856  adjacency.insert(siit->get()->ent);
857  siit = side_table.get<2>().lower_bound(MBQUAD);
858  hi_siit = side_table.get<2>().upper_bound(MBQUAD);
859  for (; siit != hi_siit; siit++)
860  adjacency.insert(siit->get()->ent);
861  }
862  case L2:
863  adjacency.insert(fe_ent);
864  break;
865  case NOFIELD: {
866  Range ents;
867  rval = moab.get_entities_by_handle(field_ptr.getMeshset(), ents, false);
869  adjacency.merge(ents);
870  for (Range::iterator eit = ents.begin(); eit != ents.end(); eit++) {
871  const_cast<SideNumber_multiIndex &>(fe_ptr.getSideNumberTable())
872  .insert(
873  boost::shared_ptr<SideNumber>(new SideNumber(*eit, -1, 0, 0)));
874  }
875  } break;
876  default:
877  SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
878  "this field is not implemented for TRI finite element");
879  }
881 }
#define CHKERRQ_MOAB(a)
check error code of MoAB function
Definition: definitions.h:533
field with continuous normal traction
Definition: definitions.h:181
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:519
scalar or vector of scalars describe (no true field)
Definition: definitions.h:178
multi_index_container< boost::shared_ptr< SideNumber >, indexed_by< hashed_unique< member< SideNumber, EntityHandle, &SideNumber::ent > >, ordered_non_unique< composite_key< SideNumber, const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType >, member< SideNumber, char, &SideNumber::side_number > > >, ordered_non_unique< const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType > > > > SideNumber_multiIndex
SideNumber_multiIndex for SideNumber.
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return() ...
Definition: definitions.h:526
static MoFEMErrorCodeGeneric< moab::ErrorCode > rval
Definition: Common.hpp:78
field with continuous tangents
Definition: definitions.h:180
continuous field
Definition: definitions.h:179
field with C-1 continuity
Definition: definitions.h:182

◆ defaultTet()

MoFEMErrorCode MoFEM::DefaultElementAdjacency::defaultTet ( Interface moab,
const Field field_ptr,
const EntFiniteElement fe_ptr,
Range &  adjacency 
)
static

Definition at line 675 of file FEMultiIndices.cpp.

677  {
679  ErrorCode rval;
680  EntityHandle fe_ent = fe_ptr.getEnt();
681  switch (field_ptr.getSpace()) {
682  case H1:
683  rval = moab.get_connectivity(&fe_ent, 1, adjacency, true);
685  // rval =
686  // moab.get_adjacencies(&fe_ent,1,0,false,adjacency,moab::Interface::UNION);
687  // CHKERRQ_MOAB(rval); if(adjacency.size()>4){
688  // Range topo_nodes;
689  // rval = moab.get_connectivity(&fe_ent,1,topo_nodes,true);
690  // CHKERRQ_MOAB(rval); Range mid_nodes; rval =
691  // moab.get_connectivity(&fe_ent,1,mid_nodes,false); CHKERRQ_MOAB(rval);
692  // mid_nodes = subtract(mid_nodes,topo_nodes);
693  // adjacency = subtract(adjacency,mid_nodes);
694  // }
695  // if(adjacency.size()<4) {
696  // SETERRQ(PETSC_COMM_SELF,MOFEM_DATA_INCONSISTENCY,"TET has at least 4
697  // adjacent nodes; it can has more if user add more adjacencies");
698  // }
699  case HCURL:
700  rval = moab.get_adjacencies(&fe_ent, 1, 1, false, adjacency,
701  moab::Interface::UNION);
703  case HDIV:
704  rval = moab.get_adjacencies(&fe_ent, 1, 2, false, adjacency,
705  moab::Interface::UNION);
707  case L2:
708  adjacency.insert(fe_ent);
709  break;
710  case NOFIELD: {
711  Range ents;
712  rval = moab.get_entities_by_handle(field_ptr.getMeshset(), ents, false);
714  adjacency.merge(ents);
715  for (Range::iterator eit = ents.begin(); eit != ents.end(); eit++) {
716  const_cast<SideNumber_multiIndex &>(fe_ptr.getSideNumberTable())
717  .insert(
718  boost::shared_ptr<SideNumber>(new SideNumber(*eit, -1, 0, 0)));
719  }
720  } break;
721  default:
722  SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
723  "this field is not implemented for TRI finite element");
724  }
725  // build side table
726  for (Range::iterator eit = adjacency.begin(); eit != adjacency.end(); eit++) {
727  fe_ptr.getSideNumberPtr(*eit);
728  }
730 }
#define CHKERRQ_MOAB(a)
check error code of MoAB function
Definition: definitions.h:533
field with continuous normal traction
Definition: definitions.h:181
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:519
scalar or vector of scalars describe (no true field)
Definition: definitions.h:178
multi_index_container< boost::shared_ptr< SideNumber >, indexed_by< hashed_unique< member< SideNumber, EntityHandle, &SideNumber::ent > >, ordered_non_unique< composite_key< SideNumber, const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType >, member< SideNumber, char, &SideNumber::side_number > > >, ordered_non_unique< const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType > > > > SideNumber_multiIndex
SideNumber_multiIndex for SideNumber.
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return() ...
Definition: definitions.h:526
static MoFEMErrorCodeGeneric< moab::ErrorCode > rval
Definition: Common.hpp:78
field with continuous tangents
Definition: definitions.h:180
continuous field
Definition: definitions.h:179
field with C-1 continuity
Definition: definitions.h:182

◆ defaultTri()

MoFEMErrorCode MoFEM::DefaultElementAdjacency::defaultTri ( Interface moab,
const Field field_ptr,
const EntFiniteElement fe_ptr,
Range &  adjacency 
)
static

Definition at line 603 of file FEMultiIndices.cpp.

605  {
607  ErrorCode rval;
608  // Range nodes,edges;
609  EntityHandle fe_ent = fe_ptr.getEnt();
610  switch (field_ptr.getSpace()) {
611  case H1:
612  rval = moab.get_connectivity(&fe_ent, 1, adjacency, true);
614  // moab.get_connectivity(&fe_ent,1,nodes,true);
615  // use get adjacencies, this will allow take in account adjacencies set user
616  // rval =
617  // moab.get_adjacencies(&fe_ent,1,0,false,nodes,moab::Interface::UNION);
618  // CHKERRQ_MOAB(rval);
619  // {
620  // Range topo_nodes;
621  // rval = moab.get_connectivity(&fe_ent,1,topo_nodes,true);
622  // CHKERRQ_MOAB(rval); Range mid_nodes; rval =
623  // moab.get_connectivity(&fe_ent,1,mid_nodes,false); CHKERRQ_MOAB(rval);
624  // mid_nodes = subtract(mid_nodes,topo_nodes);
625  // nodes = subtract(nodes,mid_nodes);
626  // }
627  // adjacency.insert(nodes.begin(),nodes.end());
628  // rval = moab.get_adjacencies(&fe_ent,1,1,false,edges); CHKERRQ_MOAB(rval);
629  // adjacency.insert(edges.begin(),edges.end());
630  // for(Range::iterator eeit = edges.begin();eeit!=edges.end();eeit++) {
631  // fe_ptr.getSideNumberPtr(*eeit);
632  // }
633  // //add faces
634  // adjacency.insert(fe_ent);
635  // break;
636  case HCURL:
637  rval = moab.get_adjacencies(&fe_ent, 1, 1, false, adjacency,
638  moab::Interface::UNION);
640  // adjacency.insert(edges.begin(),edges.end());
641  // for(Range::iterator eeit = edges.begin();eeit!=edges.end();eeit++) {
642  // fe_ptr.getSideNumberPtr(*eeit);
643  // }
644  // //add faces
645  // adjacency.insert(fe_ent);
646  // break;
647  case HDIV:
648  adjacency.insert(fe_ent);
649  break;
650  case NOFIELD: {
651  Range ents;
652  rval = moab.get_entities_by_handle(field_ptr.getMeshset(), ents, false);
654  adjacency.merge(ents);
655  for (Range::iterator eit = ents.begin(); eit != ents.end(); eit++) {
656  const_cast<SideNumber_multiIndex &>(fe_ptr.getSideNumberTable())
657  .insert(
658  boost::shared_ptr<SideNumber>(new SideNumber(*eit, -1, 0, 0)));
659  }
660  } break;
661  case L2:
662  adjacency.insert(fe_ent); // add this just in case, if L2 is on skeleton
663  break;
664  default:
665  SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
666  "this field is not implemented for TRI finite element");
667  }
668  // build side table
669  for (Range::iterator eit = adjacency.begin(); eit != adjacency.end(); eit++) {
670  fe_ptr.getSideNumberPtr(*eit);
671  }
673 }
#define CHKERRQ_MOAB(a)
check error code of MoAB function
Definition: definitions.h:533
field with continuous normal traction
Definition: definitions.h:181
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:519
scalar or vector of scalars describe (no true field)
Definition: definitions.h:178
multi_index_container< boost::shared_ptr< SideNumber >, indexed_by< hashed_unique< member< SideNumber, EntityHandle, &SideNumber::ent > >, ordered_non_unique< composite_key< SideNumber, const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType >, member< SideNumber, char, &SideNumber::side_number > > >, ordered_non_unique< const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType > > > > SideNumber_multiIndex
SideNumber_multiIndex for SideNumber.
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return() ...
Definition: definitions.h:526
static MoFEMErrorCodeGeneric< moab::ErrorCode > rval
Definition: Common.hpp:78
field with continuous tangents
Definition: definitions.h:180
continuous field
Definition: definitions.h:179
field with C-1 continuity
Definition: definitions.h:182

◆ defaultVertex()

MoFEMErrorCode MoFEM::DefaultElementAdjacency::defaultVertex ( Interface moab,
const Field field_ptr,
const EntFiniteElement fe_ptr,
Range &  adjacency 
)
static

Definition at line 525 of file FEMultiIndices.cpp.

527  {
529 
530  switch (field_ptr.getSpace()) {
531  case H1:
532  adjacency.insert(fe_ptr.getEnt());
533  break;
534  case NOFIELD: {
535  Range ents;
536  rval = moab.get_entities_by_handle(field_ptr.getMeshset(), ents, false);
538  adjacency.merge(ents);
539  for (Range::iterator eit = ents.begin(); eit != ents.end(); eit++) {
540  const_cast<SideNumber_multiIndex &>(fe_ptr.getSideNumberTable())
541  .insert(
542  boost::shared_ptr<SideNumber>(new SideNumber(*eit, -1, 0, 0)));
543  }
544  } break;
545  default:
546  SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
547  "this field is not implemented for VERTEX finite element");
548  }
549  // build side table
550  for (Range::iterator eit = adjacency.begin(); eit != adjacency.end(); eit++) {
551  fe_ptr.getSideNumberPtr(*eit);
552  }
554 }
#define CHKERRQ_MOAB(a)
check error code of MoAB function
Definition: definitions.h:533
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:519
scalar or vector of scalars describe (no true field)
Definition: definitions.h:178
multi_index_container< boost::shared_ptr< SideNumber >, indexed_by< hashed_unique< member< SideNumber, EntityHandle, &SideNumber::ent > >, ordered_non_unique< composite_key< SideNumber, const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType >, member< SideNumber, char, &SideNumber::side_number > > >, ordered_non_unique< const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType > > > > SideNumber_multiIndex
SideNumber_multiIndex for SideNumber.
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return() ...
Definition: definitions.h:526
static MoFEMErrorCodeGeneric< moab::ErrorCode > rval
Definition: Common.hpp:78
continuous field
Definition: definitions.h:179

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