v0.15.0
Loading...
Searching...
No Matches
Functions | Variables
uniform_mesh_refinement.cpp File Reference

Uniformly refine mesh. More...

#include <MoFEM.hpp>

Go to the source code of this file.

Functions

int main (int argc, char *argv[])
 

Variables

static char help []
 

Detailed Description

Uniformly refine mesh.

Definition in file uniform_mesh_refinement.cpp.

Function Documentation

◆ main()

int main ( int  argc,
char *  argv[] 
)

Definition at line 19 of file uniform_mesh_refinement.cpp.

19 {
20
21 MoFEM::Core::Initialize(&argc, &argv, (char *)0, help);
22
23 try {
24
25 // global variables
26 char mesh_file_name[255];
27 char mesh_out_file[255] = "out.h5m";
28 int dim = 3;
29 int nb_levels = 1;
30 PetscBool shift = PETSC_TRUE;
31 PetscBool flg_file = PETSC_FALSE;
32 PetscBool debug = PETSC_FALSE;
33
34 PetscOptionsBegin(PETSC_COMM_WORLD, "", "none", "none");
35
36 CHKERR PetscOptionsString("-my_file", "mesh file name", "", "mesh.h5m",
37 mesh_file_name, 255, &flg_file);
38 if (flg_file != PETSC_TRUE)
39 CHKERR PetscOptionsString("-file_name", "mesh file name", "", "mesh.h5m",
40 mesh_file_name, 255, &flg_file);
41 CHKERR PetscOptionsString("-output_file", "output mesh file name", "",
42 "mesh.h5m", mesh_out_file, 255, PETSC_NULLPTR);
43 CHKERR PetscOptionsInt("-dim", "entities dim", "", dim, &dim, PETSC_NULLPTR);
44 CHKERR PetscOptionsInt("-nb_levels", "number of refinement levels", "",
45 nb_levels, &nb_levels, PETSC_NULLPTR);
46 CHKERR PetscOptionsBool("-shift",
47 "shift bits, squash entities of refined elements",
48 "", shift, &shift, PETSC_NULLPTR);
49 CHKERR PetscOptionsBool("-debug",
50 "write additional files with bit ref levels", "",
51 debug, &debug, PETSC_NULLPTR);
52
53 PetscOptionsEnd();
54
55 moab::Core mb_instance;
56 moab::Interface &moab = mb_instance;
57 ParallelComm *pcomm = ParallelComm::get_pcomm(&moab, MYPCOMM_INDEX);
58 if (pcomm == NULL)
59 pcomm = new ParallelComm(&moab, PETSC_COMM_WORLD);
60
61 const char *option;
62 option = "";
63 CHKERR moab.load_file(mesh_file_name, 0, option);
64
65 // Create MoFEM database
66 MoFEM::Core core(moab);
67 MoFEM::Interface &m_field = core;
68
69 if (flg_file != PETSC_TRUE) {
70 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
71 "*** ERROR -my_file (-file_name) (mesh file needed)");
72 }
73
74 BitRefManager *bit_ref_manager;
75 CHKERR m_field.getInterface(bit_ref_manager);
76
77 auto bit = [](auto l) { return BitRefLevel().set(l); };
78
79 CHKERR bit_ref_manager->setBitRefLevelByDim(0, dim, bit(0));
80
81 for (auto l = 0; l != nb_levels; ++l) {
82 Range ents;
83 CHKERR bit_ref_manager->getEntitiesByDimAndRefLevel(
84 bit(l), BitRefLevel().set(), dim, ents);
85
86 Range edges;
87 CHKERR moab.get_adjacencies(ents, 1, true, edges, moab::Interface::UNION);
88
89 EntityHandle meshset_ref_edges;
90 CHKERR moab.create_meshset(MESHSET_SET, meshset_ref_edges);
91 CHKERR moab.add_entities(meshset_ref_edges, edges);
92
93 MeshRefinement *refine = m_field.getInterface<MeshRefinement>();
94
95 CHKERR refine->addVerticesInTheMiddleOfEdges(meshset_ref_edges,
96 bit(l + 1));
97 if (dim == 3) {
98 CHKERR refine->refineTets(ents, bit(l + 1));
99 } else if (dim == 2) {
100 CHKERR refine->refineTris(ents, bit(l + 1));
101 } else {
102 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
103 "Refinement implemented only for three and two dimensions");
104 }
105
106 auto update_meshsets = [&]() {
107 MoFEMFunctionBegin;
108 // update cubit meshsets
109 for (_IT_CUBITMESHSETS_FOR_LOOP_(m_field, ciit)) {
110 EntityHandle cubit_meshset = ciit->meshset;
111 CHKERR bit_ref_manager->updateMeshsetByEntitiesChildren(
112 cubit_meshset, bit(l + 1), cubit_meshset, MBMAXTYPE, true);
113 }
114 MoFEMFunctionReturn(0);
115 };
116
117 auto update_partition_sets = [&]() {
118 MoFEMFunctionBegin;
119
120 ParallelComm *pcomm = ParallelComm::get_pcomm(
121 &m_field.get_moab(), m_field.get_basic_entity_data_ptr()->pcommID);
122 Tag part_tag = pcomm->part_tag();
123
124 Range r_tagged_sets;
125 CHKERR m_field.get_moab().get_entities_by_type_and_tag(
126 0, MBENTITYSET, &part_tag, NULL, 1, r_tagged_sets,
127 moab::Interface::UNION);
128
129 std::vector<EntityHandle> tagged_sets(r_tagged_sets.size());
130 std::copy(r_tagged_sets.begin(), r_tagged_sets.end(),
131 tagged_sets.begin());
132
133 auto order_tagged_sets = [&]() {
134 MoFEMFunctionBegin;
135 std::vector<int> parts(tagged_sets.size());
136 CHKERR m_field.get_moab().tag_get_data(
137 part_tag, &*tagged_sets.begin(), tagged_sets.size(),
138 &*parts.begin());
139 map<int, EntityHandle> m_tagged_sets;
140 for (int p = 0; p != tagged_sets.size(); ++p) {
141 m_tagged_sets[parts[p]] = tagged_sets[p];
142 }
143 for (int p = 0; p != tagged_sets.size(); ++p) {
144 tagged_sets[p] = m_tagged_sets.at(p);
145 }
146 MoFEMFunctionReturn(0);
147 };
148
149 auto add_children = [&]() {
150 MoFEMFunctionBegin;
151 std::vector<Range> part_ents(tagged_sets.size());
152
153 for (int p = 0; p != tagged_sets.size(); ++p) {
154 Range ents;
155 CHKERR moab.get_entities_by_dimension(tagged_sets[p], dim, ents,
156 true);
157 CHKERR bit_ref_manager->filterEntitiesByRefLevel(
158 bit(l), BitRefLevel().set(), ents);
159
160 Range children;
161 CHKERR bit_ref_manager->updateRangeByChildren(ents, children);
162 children = children.subset_by_dimension(dim);
163 CHKERR bit_ref_manager->filterEntitiesByRefLevel(
164 bit(l + 1), BitRefLevel().set(), children);
165
166 Range adj;
167 for (auto d = 1; d != dim; ++d) {
168 CHKERR moab.get_adjacencies(children.subset_by_dimension(dim), d,
169 false, adj, moab::Interface::UNION);
170 }
171
172 part_ents[p].merge(children);
173 part_ents[p].merge(adj);
174 }
175
176 for (int p = 1; p != tagged_sets.size(); ++p) {
177 for (int pp = 0; pp != p; pp++) {
178 part_ents[p] = subtract(part_ents[p], part_ents[pp]);
179 }
180 }
181
182 for (int p = 0; p != tagged_sets.size(); ++p) {
183 CHKERR moab.add_entities(tagged_sets[p], part_ents[p]);
184 CHKERR moab.tag_clear_data(part_tag, part_ents[p], &p);
185 }
186
187 if (debug) {
188
189 auto save_range = [&](const std::string name, const Range &r) {
190 MoFEMFunctionBegin;
191 auto meshset_ptr = get_temp_meshset_ptr(m_field.get_moab());
192 CHKERR m_field.get_moab().add_entities(*meshset_ptr, r);
193 CHKERR m_field.get_moab().write_file(name.c_str(), "VTK", "",
194 meshset_ptr->get_ptr(), 1);
195 MoFEMFunctionReturn(0);
196 };
197
198 for (int p = 0; p != tagged_sets.size(); ++p) {
199 MOFEM_LOG("WORLD", Sev::inform)
200 << "Write part " << p << " level " << l;
201 Range ents;
202 CHKERR m_field.get_moab().get_entities_by_handle(tagged_sets[p],
203 ents, true);
204 CHKERR bit_ref_manager->filterEntitiesByRefLevel(
205 bit(l + 1), BitRefLevel().set(), ents);
206 CHKERR save_range("part" + boost::lexical_cast<std::string>(p) +
207 "_" + boost::lexical_cast<std::string>(l) +
208 ".vtk",
209 ents);
210 }
211 }
212
213 MoFEMFunctionReturn(0);
214 };
215
216 CHKERR order_tagged_sets();
217 CHKERR add_children();
218
219 MoFEMFunctionReturn(0);
220 };
221
222 CHKERR update_partition_sets();
223 CHKERR update_meshsets();
224
225 CHKERR moab.delete_entities(&meshset_ref_edges, 1);
226 }
227
228 if (debug) {
229 for (int l = 0; l <= nb_levels; ++l) {
230 MOFEM_LOG("WORLD", Sev::inform) << "Write level " << l;
231 CHKERR bit_ref_manager->writeBitLevel(
232 bit(l), BitRefLevel().set(),
233 ("level" + boost::lexical_cast<std::string>(l) + ".vtk").c_str(),
234 "VTK", "");
235 }
236 }
237
238 if (shift == PETSC_TRUE) {
239 MOFEM_LOG("WORLD", Sev::inform) << "Shift bits";
240 CHKERR core.getInterface<BitRefManager>()->shiftRightBitRef(
241 nb_levels, BitRefLevel().set(), VERBOSE);
242 }
243
244 CHKERR moab.write_file(mesh_out_file);
245 }
246 CATCH_ERRORS;
247
248 MoFEM::Core::Finalize();
249 CHKERRQ(ierr);
250
251 return 0;
252}
VERBOSE
@ VERBOSE
Definition definitions.h:222
CATCH_ERRORS
#define CATCH_ERRORS
Catch errors.
Definition definitions.h:385
MYPCOMM_INDEX
#define MYPCOMM_INDEX
default communicator number PCOMM
Definition definitions.h:228
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition definitions.h:359
MOFEM_DATA_INCONSISTENCY
@ MOFEM_DATA_INCONSISTENCY
Definition definitions.h:31
MOFEM_NOT_IMPLEMENTED
@ MOFEM_NOT_IMPLEMENTED
Definition definitions.h:32
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition definitions.h:432
CHKERR
#define CHKERR
Inline error check.
Definition definitions.h:551
MoFEM::BitRefManager::updateMeshsetByEntitiesChildren
MoFEMErrorCode updateMeshsetByEntitiesChildren(const EntityHandle parent, const BitRefLevel &parent_bit, const BitRefLevel &parent_mask, const BitRefLevel &child_bit, const BitRefLevel &child_mask, const EntityHandle child, EntityType child_type, const bool recursive=false, int verb=0)
Get child entities form meshset containing parent entities.
Definition BitRefManager.cpp:1030
MoFEM::BitRefManager::getEntitiesByDimAndRefLevel
MoFEMErrorCode getEntitiesByDimAndRefLevel(const BitRefLevel bit, const BitRefLevel mask, const int dim, const EntityHandle meshset, int verb=0) const
add all ents from ref level given by bit to meshset
Definition BitRefManager.cpp:823
MoFEM::BitRefManager::setBitRefLevelByDim
MoFEMErrorCode setBitRefLevelByDim(const EntityHandle meshset, const int dim, const BitRefLevel bit, int verb=QUIET) const
Set the Bit Ref Level By Dim object.
Definition BitRefManager.cpp:500
MoFEM::BitRefManager::updateRangeByChildren
MoFEMErrorCode updateRangeByChildren(const Range &parent, Range &child, MoFEMTypes bh=MF_ZERO)
Update range by childrens.
Definition BitRefManager.cpp:1145
MOFEM_LOG
#define MOFEM_LOG(channel, severity)
Log.
Definition LogManager.hpp:316
_IT_CUBITMESHSETS_FOR_LOOP_
#define _IT_CUBITMESHSETS_FOR_LOOP_(MESHSET_MANAGER, IT)
Iterator that loops over all the Cubit MeshSets in a moFEM field.
Definition MeshsetsManager.hpp:57
bit
auto bit
set bit
Definition hanging_node_approx.cpp:75
nb_levels
constexpr int nb_levels
Definition level_set.cpp:58
l
FTensor::Index< 'l', 3 > l
Definition matrix_function.cpp:21
mesh_file_name
char mesh_file_name[255]
Definition mesh_smoothing.cpp:22
MoFEM::Exceptions::ierr
static MoFEMErrorCodeGeneric< PetscErrorCode > ierr
Definition Exceptions.hpp:76
MoFEM::Types::BitRefLevel
std::bitset< BITREFLEVEL_SIZE > BitRefLevel
Bit structure attached to each entity identifying to what mesh entity is attached.
Definition Types.hpp:40
MoFEM::debug
static const bool debug
Definition ConstrainMatrixCtx.cpp:9
MoFEM::get_temp_meshset_ptr
auto get_temp_meshset_ptr(moab::Interface &moab)
Create smart pointer to temporary meshset.
Definition Templates.hpp:1980
sdf_hertz_3d.d
int d
Definition sdf_hertz_3d.py:5
sdf.r
int r
Definition sdf.py:8
MoFEM::BitRefManager
Managing BitRefLevels.
Definition BitRefManager.hpp:21
MoFEM::BitRefManager::filterEntitiesByRefLevel
MoFEMErrorCode filterEntitiesByRefLevel(const BitRefLevel bit, const BitRefLevel mask, Range &ents, int verb=QUIET) const
filter entities by bit ref level
Definition BitRefManager.cpp:747
MoFEM::BitRefManager::writeBitLevel
MoFEMErrorCode writeBitLevel(const BitRefLevel bit, const BitRefLevel mask, const char *file_name, const char *file_type, const char *options, const bool check_for_empty=true) const
Write bit ref level to file.
Definition BitRefManager.cpp:635
MoFEM::CoreInterface::get_moab
virtual moab::Interface & get_moab()=0
MoFEM::CoreInterface::get_basic_entity_data_ptr
virtual boost::shared_ptr< BasicEntityData > & get_basic_entity_data_ptr()=0
Get pointer to basic entity data.
MoFEM::CoreTmp< 0 >
Core (interface) class.
Definition Core.hpp:82
MoFEM::CoreTmp< 0 >::Initialize
static MoFEMErrorCode Initialize(int *argc, char ***args, const char file[], const char help[])
Initializes the MoFEM database PETSc, MOAB and MPI.
Definition Core.cpp:72
MoFEM::CoreTmp< 0 >::Finalize
static MoFEMErrorCode Finalize()
Checks for options to be called at the conclusion of the program.
Definition Core.cpp:118
MoFEM::DeprecatedCoreInterface
Deprecated interface functions.
Definition DeprecatedCoreInterface.hpp:16
MoFEM::MeshRefinement
Mesh refinement interface.
Definition MeshRefinement.hpp:26
MoFEM::MeshRefinement::refineTets
MoFEMErrorCode refineTets(const EntityHandle meshset, const BitRefLevel &bit, int verb=QUIET, const bool debug=false)
refine TET in the meshset
Definition MeshRefinement.cpp:197
MoFEM::MeshRefinement::addVerticesInTheMiddleOfEdges
MoFEMErrorCode addVerticesInTheMiddleOfEdges(const EntityHandle meshset, const BitRefLevel &bit, const bool recursive=false, int verb=QUIET, EntityHandle start_v=0)
make vertices in the middle of edges in meshset and add them to refinement levels defined by bit
Definition MeshRefinement.cpp:42
MoFEM::MeshRefinement::refineTris
MoFEMErrorCode refineTris(const EntityHandle meshset, const BitRefLevel &bit, int verb=QUIET, const bool debug=false)
refine triangles in the meshset
Definition MeshRefinement.cpp:922
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
Definition UnknownInterface.hpp:93
save_range
auto save_range
Definition thermo_elastic.cpp:121
help
static char help[]
Definition uniform_mesh_refinement.cpp:10

Variable Documentation

◆ help

char help[]
static
Initial value:
= "Uniform mesh refinement\n\n"
"Usage example:\n"
"$ ./uniform_mesh_refinement -my_file mesh.h5m "
"-output_file refined_mesh.h5m"
"\n\n"

Definition at line 10 of file uniform_mesh_refinement.cpp.

Generated by Doxygen 1.9.8 and hosted at University of Glasgow