libMesh
Enumerations | Functions
meshtool.C File Reference

Go to the source code of this file.

Enumerations

enum  BoundaryMeshWriteMode { BM_DISABLED =0, BM_MESH_ONLY }
 

Functions

void usage (const std::string &prog_name)
 
int main (int argc, char **argv)
 

Enumeration Type Documentation

◆ BoundaryMeshWriteMode

enum BoundaryMeshWriteMode
Enumerator
BM_DISABLED 
BM_MESH_ONLY 

Definition at line 53 of file meshtool.C.

53 {BM_DISABLED=0, BM_MESH_ONLY};

Function Documentation

◆ main()

int main ( int  argc,
char **  argv 
)

Definition at line 58 of file meshtool.C.

59 {
60  LibMeshInit init(argc, argv);
61 
62  unsigned int n_subdomains = 1;
63  unsigned int n_rsteps = 0;
64  double dist_fact = 0.;
65  bool verbose = false;
66  BoundaryMeshWriteMode write_bndry = BM_DISABLED;
67  bool convert_first_order = false;
68  unsigned int convert_second_order = 0;
69  bool triangulate = false;
70  bool do_quality = false;
71  ElemQuality quality_type = DIAGONAL;
72 
73 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
74  bool addinfelems = false;
75  InfElemBuilder::InfElemOriginValue origin_x(false, 0.);
76  InfElemBuilder::InfElemOriginValue origin_y(false, 0.);
77  InfElemBuilder::InfElemOriginValue origin_z(false, 0.);
78  bool x_sym=false;
79  bool y_sym=false;
80  bool z_sym=false;
81 #endif
82 
83  std::vector<std::string> names;
84  std::vector<std::string> var_names;
85  std::vector<Number> soln;
86 
87  // Check for minimum number of command line args
88  if (argc < 3)
89  usage(std::string(argv[0]));
90 
91  // Create a GetPot object to parse the command line
92  GetPot command_line (argc, argv);
93 
94  // Print usage and exit immediately if user asked for help.
95  if (command_line.search(2, "-h", "-?"))
96  usage(argv[0]);
97 
98  // Input file name
99  if (command_line.search(1, "-i"))
100  {
101  std::string tmp;
102  tmp = command_line.next(tmp);
103  if (names.empty())
104  names.push_back(tmp);
105  else
106  libmesh_error_msg("ERROR: Input name must precede output name!");
107  }
108 
109  // Output file name
110  if (command_line.search(1, "-o"))
111  {
112  std::string tmp;
113  tmp = command_line.next(tmp);
114  if (!names.empty())
115  names.push_back(tmp);
116  else
117  libmesh_error_msg("ERROR: Input name must precede output name!");
118  }
119 
120  // Get the mesh distortion factor
121  if (command_line.search(1, "-D"))
122  dist_fact = command_line.next(dist_fact);
123 
124  // Number of refinements
125  if (command_line.search(1, "-r"))
126  {
127  int tmp;
128  tmp = command_line.next(tmp);
129  n_rsteps = cast_int<unsigned int>(tmp);
130  }
131 
132  // Number of subdomains for partitioning
133  if (command_line.search(1, "-p"))
134  {
135  int tmp;
136  tmp = command_line.next(tmp);
137  n_subdomains = cast_int<unsigned int>(tmp);
138  }
139 
140  // Should we call all_tri()?
141  if (command_line.search(1, "-t"))
142  triangulate = true;
143 
144  // Should we calculate element quality?
145  if (command_line.search(1, "-q"))
146  {
147  do_quality = true;
148  std::string tmp;
149  tmp = command_line.next(tmp);
150  if (tmp != "")
151  quality_type = Utility::string_to_enum<ElemQuality>(tmp);
152  }
153 
154  // Should we be verbose?
155  if (command_line.search(1, "-v"))
156  verbose = true;
157 
158  // Should we write the boundary?
159  if (command_line.search(1, "-b"))
160  write_bndry = BM_MESH_ONLY;
161 
162  // Should we convert all elements to 1st order?
163  if (command_line.search(1, "-1"))
164  convert_first_order = true;
165 
166  // Should we convert all elements to 2nd order?
167  if (command_line.search(1, "-2"))
168  convert_second_order = 2;
169 
170  // Should we convert all elements to "full" 2nd order?
171  if (command_line.search(1, "-3"))
172  convert_second_order = 22;
173 
174 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
175 
176  // Add infinte elements
177  if (command_line.search(1, "-a"))
178  addinfelems = true;
179 
180  // Specify origin x coordinate
181  if (command_line.search(1, "-x"))
182  {
183  origin_x.first = true;
184  origin_x.second = command_line.next(origin_x.second);
185  }
186 
187  // Specify origin y coordinate
188  if (command_line.search(1, "-y"))
189  {
190  origin_y.first = true;
191  origin_y.second = command_line.next(origin_y.second);
192  }
193 
194  // Specify origin z coordinate
195  if (command_line.search(1, "-z"))
196  {
197  origin_z.first = true;
198  origin_z.second = command_line.next(origin_z.second);
199  }
200 
201  // Symmetries
202  if (command_line.search(1, "-X"))
203  x_sym = true;
204  if (command_line.search(1, "-Y"))
205  y_sym = true;
206  if (command_line.search(1, "-Z"))
207  z_sym = true;
208 
209 #endif // LIBMESH_ENABLE_INFINITE_ELEMENTS
210 
211  // Read the input mesh
212  Mesh mesh(init.comm());
213  if (!names.empty())
214  {
215  mesh.read(names[0]);
216 
217  if (verbose)
218  {
219  mesh.print_info();
220  mesh.get_boundary_info().print_summary();
221  }
222  }
223 
224  else
225  {
226  libMesh::out << "No input specified." << std::endl;
227  return 1;
228  }
229 
230 
231 
232 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
233 
234  if (addinfelems)
235  {
236  if (names.size() == 3)
237  libmesh_error_msg("ERROR: Invalid combination: Building infinite elements\n"
238  << "not compatible with solution import.");
239 
240  if (write_bndry != BM_DISABLED)
241  libmesh_error_msg("ERROR: Invalid combination: Building infinite elements\n"
242  << "not compatible with writing boundary conditions.");
243 
244  // Sanity checks: -X/Y/Z can only be used, when the
245  // corresponding coordinate is also given (using -x/y/z)
246  if ((x_sym && !origin_x.first) || // claim x-symmetry, but x-coordinate of origin not given!
247  (y_sym && !origin_y.first) || // the same for y
248  (z_sym && !origin_z.first)) // the same for z
249  libmesh_error_msg("ERROR: When x-symmetry is requested using -X, then\n"
250  << "the option -x <coord> also has to be given.\n"
251  << "This holds obviously for y and z, too.");
252 
253  // build infinite elements
254  InfElemBuilder(mesh).build_inf_elem(origin_x, origin_y, origin_z,
255  x_sym, y_sym, z_sym,
256  verbose);
257 
258  if (verbose)
259  {
260  mesh.print_info();
261  mesh.get_boundary_info().print_summary();
262  }
263 
264  }
265 
266  // sanity check
267  else if ((origin_x.first || origin_y.first || origin_z.first) ||
268  (x_sym || y_sym || z_sym))
269  libmesh_error_msg("ERROR: -x/-y/-z/-X/-Y/-Z is only to be used when\n"
270  << "the option -a is also specified!");
271 
272 #endif
273 
274 
275  // Maybe Triangulate
276  if (triangulate)
277  {
278  if (verbose)
279  libMesh::out << "...Converting to all simplices...\n";
280 
281  MeshTools::Modification::all_tri(mesh);
282  }
283 
284  // Compute Shape quality metrics
285  if (do_quality)
286  {
287  StatisticsVector<Real> sv;
288  sv.reserve(mesh.n_elem());
289 
290  libMesh::out << "Quality type is: " << Quality::name(quality_type) << std::endl;
291 
292  // What are the quality bounds for this element?
293  std::pair<Real, Real> bounds = mesh.elem_ref(0).qual_bounds(quality_type);
294  libMesh::out << "Quality bounds for this element type are: ("
295  << bounds.first
296  << ", "
297  << bounds.second
298  << ") "
299  << std::endl;
300 
301  for (const auto & elem : mesh.active_element_ptr_range())
302  sv.push_back(elem->quality(quality_type));
303 
304  const unsigned int n_bins = 10;
305  libMesh::out << "Avg. shape quality: " << sv.mean() << std::endl;
306 
307  // Find element indices below the specified cutoff.
308  // These might be considered "bad" elements which need refinement.
309  std::vector<dof_id_type> bad_elts = sv.cut_below(0.8);
310  libMesh::out << "Found " << bad_elts.size()
311  << " of " << mesh.n_elem()
312  << " elements below the cutoff." << std::endl;
313 
314  // Compute the histogram for this distribution
315  std::vector<dof_id_type> histogram;
316  sv.histogram(histogram, n_bins);
317 
318  const bool do_matlab = true;
319 
320  if (do_matlab)
321  {
322  std::ofstream out ("histo.m");
323 
324  out << "% This is a sample histogram plot for Matlab." << std::endl;
325  out << "bin_members = [" << std::endl;
326  for (unsigned int i=0; i<n_bins; i++)
327  out << static_cast<Real>(histogram[i]) / static_cast<Real>(mesh.n_elem())
328  << std::endl;
329  out << "];" << std::endl;
330 
331  std::vector<Real> bin_coords(n_bins);
332  const Real max = *(std::max_element(sv.begin(), sv.end()));
333  const Real min = *(std::min_element(sv.begin(), sv.end()));
334  const Real delta = (max - min) / static_cast<Real>(n_bins);
335  for (unsigned int i=0; i<n_bins; i++)
336  bin_coords[i] = min + (i * delta) + delta / 2.0 ;
337 
338  out << "bin_coords = [" << std::endl;
339  for (unsigned int i=0; i<n_bins; i++)
340  out << bin_coords[i] << std::endl;
341  out << "];" << std::endl;
342 
343  out << "bar(bin_coords, bin_members, 1);" << std::endl;
344  out << "hold on" << std::endl;
345  out << "plot (bin_coords, 0, 'kx');" << std::endl;
346  out << "xlabel('Quality (0=Worst, 1=Best)');" << std::endl;
347  out << "ylabel('Percentage of elements in each bin');" << std::endl;
348  out << "axis([" << min << "," << max << ",0, max(bin_members)]);" << std::endl;
349 
350  out << "title('" << Quality::name(quality_type) << "');" << std::endl;
351 
352  }
353  }
354 
355  // Possibly convert all linear elements to second-order
356  // counterparts
357  if (convert_first_order)
358  {
359  if (verbose)
360  libMesh::out << "Converting elements to first order counterparts\n";
361 
362  mesh.all_first_order();
363 
364  if (verbose)
365  {
366  mesh.print_info();
367  mesh.get_boundary_info().print_summary();
368  }
369  }
370 
371  // Possibly convert all linear elements to second-order counterparts
372  if (convert_second_order > 0)
373  {
374  bool second_order_mode = true;
375  std:: string message = "Converting elements to second order counterparts";
376  if (convert_second_order == 2)
377  {
378  second_order_mode = false;
379  message += ", lower version: Quad4 -> Quad8, not Quad9";
380  }
381 
382  else if (convert_second_order == 22)
383  {
384  second_order_mode = true;
385  message += ", highest version: Quad4 -> Quad9";
386  }
387 
388  else
389  libmesh_error_msg("Invalid value, convert_second_order = " << convert_second_order);
390 
391  if (verbose)
392  libMesh::out << message << std::endl;
393 
394  mesh.all_second_order(second_order_mode);
395 
396  if (verbose)
397  {
398  mesh.print_info();
399  mesh.get_boundary_info().print_summary();
400  }
401  }
402 
403 
404 #ifdef LIBMESH_ENABLE_AMR
405 
406  // Possibly refine the mesh
407  if (n_rsteps > 0)
408  {
409  if (verbose)
410  libMesh::out << "Refining the mesh "
411  << n_rsteps << " times"
412  << std::endl;
413 
414  MeshRefinement mesh_refinement (mesh);
415  mesh_refinement.uniformly_refine(n_rsteps);
416 
417  if (verbose)
418  {
419  mesh.print_info();
420  mesh.get_boundary_info().print_summary();
421  }
422  }
423 
424 
425  // Possibly distort the mesh
426  if (dist_fact > 0.)
427  {
428  libMesh::out << "Distorting the mesh by a factor of "
429  << dist_fact
430  << std::endl;
431 
432  MeshTools::Modification::distort(mesh,dist_fact);
433  }
434 
435 #endif
436 
437 
438 
439  // Possibly partition the mesh
440  if (n_subdomains > 1)
441  mesh.partition(n_subdomains);
442 
443 
444  // Possibly write the mesh
445  if (names.size() >= 2)
446  {
447  // When the mesh got refined, it is likely that
448  // the user does _not_ want to write also
449  // the coarse elements, but only the active ones.
450  // Use Mesh::create_submesh() to create a mesh
451  // of only active elements, and then write _this_
452  // new mesh.
453  if (n_rsteps > 0)
454  {
455  if (verbose)
456  libMesh::out << " Mesh got refined, will write only _active_ elements." << std::endl;
457 
458  Mesh new_mesh (init.comm(), cast_int<unsigned char>(mesh.mesh_dimension()));
459 
460  mesh.create_submesh
461  (new_mesh,
462  mesh.active_elements_begin(),
463  mesh.active_elements_end());
464 
465  // now write the new_mesh
466  if (names.size() == 2)
467  new_mesh.write(names[1]);
468  else if (names.size() == 3)
469  new_mesh.write(names[1], soln, var_names);
470  else
471  libmesh_error_msg("Invalid names.size() = " << names.size());
472  }
473  else
474  {
475  if (names.size() == 2)
476  mesh.write(names[1]);
477  else if (names.size() == 3)
478  mesh.write(names[1], soln, var_names);
479  else
480  libmesh_error_msg("Invalid names.size() = " << names.size());
481  }
482 
483 
484 
485  // Possibly write the BCs
486  if (write_bndry != BM_DISABLED)
487  {
488  BoundaryMesh boundary_mesh
489  (mesh.comm(), cast_int<unsigned char>(mesh.mesh_dimension()-1));
490 
491  std::string boundary_name = "bndry_";
492  boundary_name += names[1];
493 
494  if (write_bndry == BM_MESH_ONLY)
495  mesh.get_boundary_info().sync(boundary_mesh);
496 
497  else
498  libmesh_error_msg("Invalid value write_bndry = " << write_bndry);
499 
500  if (names.size() == 2)
501  boundary_mesh.write(boundary_name);
502  else if (names.size() == 3)
503  boundary_mesh.write(boundary_name, soln, var_names);
504  }
505  }
506 
507  return 0;
508 }

References libMesh::MeshBase::active_element_ptr_range(), libMesh::MeshBase::active_elements_begin(), libMesh::MeshBase::active_elements_end(), libMesh::MeshBase::all_first_order(), libMesh::MeshBase::all_second_order(), libMesh::MeshTools::Modification::all_tri(), BM_DISABLED, BM_MESH_ONLY, libMesh::InfElemBuilder::build_inf_elem(), libMesh::ParallelObject::comm(), libMesh::StatisticsVector< T >::cut_below(), libMesh::DIAGONAL, libMesh::MeshTools::Modification::distort(), libMesh::MeshBase::elem_ref(), libMesh::MeshBase::get_boundary_info(), libMesh::StatisticsVector< T >::histogram(), libMesh::TriangleWrapper::init(), libMesh::StatisticsVector< T >::mean(), mesh, libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_elem(), libMesh::Quality::name(), libMesh::out, libMesh::MeshBase::partition(), libMesh::MeshBase::print_info(), libMesh::BoundaryInfo::print_summary(), libMesh::Elem::qual_bounds(), libMesh::MeshBase::read(), libMesh::Real, libMesh::BoundaryInfo::sync(), libMesh::MeshRefinement::uniformly_refine(), usage(), libMesh::UnstructuredMesh::write(), and libMesh::MeshBase::write().

◆ usage()

void usage ( const std::string &  prog_name)

Definition at line 511 of file meshtool.C.

512 {
513  std::ostringstream helpList;
514  helpList << "usage:\n"
515  << " "
516  << prog_name
517  << " [options] ...\n"
518  << "\n"
519  << "options:\n"
520  << " -d <dim> <dim>-dimensional mesh\n"
521  << " -i <string> Input file name\n"
522  << " -o <string> Output file name\n"
523  << "\n -b Write the boundary conditions\n"
524  << " -D <factor> Randomly move interior nodes by D*hmin\n"
525  << " -h Print help menu\n"
526  << " -p <count> Partition into <count> subdomains\n"
527 #ifdef LIBMESH_ENABLE_AMR
528  << " -r <count> Globally refine <count> times\n"
529 #endif
530  << " -t (-d 2 only) Convert to triangles first\n"
531  << " (allows to write .unv file of the\n"
532  << " boundary with the correct node ids)\n"
533  << " -v Verbose\n"
534  << " -q <metric> Evaluates the named element quality metric\n"
535  << " -1 Converts a mesh of higher order elements\n"
536  << " to their first-order counterparts:\n"
537  << " Quad8 -> Quad4, Tet10 -> Tet4 etc\n"
538  << " -2 Converts a mesh of linear elements\n"
539  << " to their second-order counterparts:\n"
540  << " Quad4 -> Quad8, Tet4 -> Tet10 etc\n"
541  << " -3 Same, but to the highest possible:\n"
542  << " Quad4 -> Quad9, Hex8 -> Hex27 etc\n"
543 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
544  << "\n -a Add infinite elements\n"
545  << " -x <coord> Specify infinite element origin\n"
546  << " -y <coord> coordinates. If none given, origin\n"
547  << " -z <coord> is determined automatically.\n"
548  << " -X When building infinite elements \n"
549  << " -Y treat mesh as x/y/z-symmetric.\n"
550  << " -Z When -X is given, -x <coord> also\n"
551  << " has to be given. Similar for y,z.\n"
552 #endif
553  << "\n"
554  << "\n"
555  << " This program is used to convert and partition from/to a variety of\n"
556  << " formats. File types are inferred from file extensions. For example,\n"
557  << " the command:\n"
558  << "\n"
559  << " ./meshtool -d 2 -i in.e -o out.plt\n"
560  << "\n"
561  << " will read a 2D mesh in the ExodusII format (from Cubit, for example)\n"
562  << " from the file in.e. It will then write the mesh in the Tecplot\n"
563  << " binary format to out.plt.\n"
564  << "\n"
565  << " and\n"
566  << "\n"
567  << " ./meshtool -d 3 -i cylinder.msh -o out.e -2\n"
568  << "\n"
569  << " will read the Gmsh formatted mesh file cylinder.msh, convert\n"
570  << " the elements to second-order, and write the output in Exodus format\n"
571  << " to out.e.\n"
572 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
573  << "\n"
574  << " and\n"
575  << "\n"
576  << " ./meshtool -d 3 -i dry.unv -o packed.gmv -a -x 30.5 -y -10.5 -X\n"
577  << "\n"
578  << " will read a 3D Universal file, determine the z-coordinate of the origin\n"
579  << " automatically, e.g. z_origin = 3., build infinite elements with the\n"
580  << " origin (30.5, -10.5, 3.) on top of volume elements, while preserving\n"
581  << " a symmetry plane through (30.5, -10.5, 3.) perpendicular to x.\n"
582  << " It is imperative that the origin lies _inside_ the given volume mesh.\n"
583  << " If not, infinite elements are not correctly built!\n"
584 #endif
585  << "\n"
586  << " Currently this program supports the following formats:\n"
587  << "\n"
588  << "INPUT:\n"
589  << " .e -- Sandia's ExodusII binary grid format\n"
590  << " .inp -- Abaqus mesh file\n"
591  << " .msh -- GMSH ASCII file\n"
592  << " .ucd -- AVS unstructured ASCII grid format\n"
593  << " .unv -- SDRC I-Deas Universal File ASCII format\n"
594  << " .xda -- libMesh human-readable ASCII format\n"
595  << " .xdr -- libMesh binary format\n"
596  << "\n"
597  << "OUTPUT:\n"
598  << " .dat -- Tecplot ASCII format\n"
599  << " .e -- Sandia's ExodusII format\n"
600  << " .exd -- Sandia's ExodusII format\n"
601  << " .fro -- ACDL's .fro format\n"
602  << " .gmv -- LANL's General Mesh Viewer format\n"
603  << " .mesh -- MEdit mesh format\n"
604  << " .msh -- GMSH ASCII file\n"
605  << " .plt -- Tecplot binary format\n"
606  << " .poly -- TetGen ASCII file\n"
607  << " .pvtu -- Paraview VTK format\n"
608  << " .ucd -- AVS's ASCII UCD format\n"
609  << " .unv -- I-deas Universal format\n"
610  << " .xda -- libMesh ASCII format\n"
611  << " .xdr -- libMesh binary format\n"
612  << " .gz -- any above format gzipped\n"
613  << " .bz2 -- any above format bzip2'ed\n"
614  << "\n";
615 
616  libMesh::out << helpList.str();
617  exit(0);
618 }

References libMesh::out.

Referenced by main().

libMesh::InfElemBuilder::build_inf_elem
const Point build_inf_elem(const bool be_verbose=false)
Build infinite elements atop a volume-based mesh, determine origin automatically.
Definition: inf_elem_builder.C:41
libMesh::Mesh
The Mesh class is a thin wrapper, around the ReplicatedMesh class by default.
Definition: mesh.h:50
libMesh::MeshBase::read
virtual void read(const std::string &name, void *mesh_data=nullptr, bool skip_renumber_nodes_and_elements=false, bool skip_find_neighbors=false)=0
Interfaces for reading/writing a mesh to/from a file.
libMesh::MeshBase::get_boundary_info
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
Definition: mesh_base.h:132
BoundaryMeshWriteMode
BoundaryMeshWriteMode
Definition: meshtool.C:53
libMesh::MeshBase::all_second_order
virtual void all_second_order(const bool full_ordered=true)=0
Converts a (conforming, non-refined) mesh with linear elements into a mesh with second-order elements...
libMesh::MeshBase::write
virtual void write(const std::string &name)=0
libMesh::MeshBase::active_element_ptr_range
virtual SimpleRange< element_iterator > active_element_ptr_range()=0
libMesh::MeshBase::n_elem
virtual dof_id_type n_elem() const =0
libMesh::MeshBase::elem_ref
virtual const Elem & elem_ref(const dof_id_type i) const
Definition: mesh_base.h:521
libMesh::InfElemBuilder::InfElemOriginValue
std::pair< bool, double > InfElemOriginValue
Useful typedef.
Definition: inf_elem_builder.h:65
libMesh::ParallelObject::comm
const Parallel::Communicator & comm() const
Definition: parallel_object.h:94
libMesh::StatisticsVector::mean
virtual Real mean() const
Definition: statistics.C:75
libMesh::StatisticsVector::histogram
virtual void histogram(std::vector< dof_id_type > &bin_members, unsigned int n_bins=10)
Definition: statistics.C:179
mesh
MeshBase & mesh
Definition: mesh_communication.C:1257
libMesh::MeshBase::mesh_dimension
unsigned int mesh_dimension() const
Definition: mesh_base.C:135
libMesh::DIAGONAL
Definition: enum_elem_quality.h:46
BM_DISABLED
Definition: meshtool.C:53
libMesh::StatisticsVector::cut_below
virtual std::vector< dof_id_type > cut_below(Real cut) const
Definition: statistics.C:326
usage
void usage(const std::string &prog_name)
Definition: meshtool.C:511
libMesh::TriangleWrapper::init
void init(triangulateio &t)
Initializes the fields of t to nullptr/0 as necessary.
libMesh::MeshRefinement
Implements (adaptive) mesh refinement algorithms for a MeshBase.
Definition: mesh_refinement.h:61
libMesh::BoundaryInfo::print_summary
void print_summary(std::ostream &out=libMesh::out) const
Prints a summary of the boundary information.
Definition: boundary_info.C:2249
libMesh::MeshBase::active_elements_begin
virtual element_iterator active_elements_begin()=0
Active, local, and negation forms of the element iterators described above.
libMesh::BoundaryMesh
The BoundaryMesh is a Mesh in its own right, but it contains a description of the boundary of some ot...
Definition: boundary_mesh.h:39
libMesh::InfElemBuilder
This class is used to build infinite elements on top of an existing mesh.
Definition: inf_elem_builder.h:53
libMesh::Elem::qual_bounds
virtual std::pair< Real, Real > qual_bounds(const ElemQuality) const
Definition: elem.h:898
libMesh::LibMeshInit
The LibMeshInit class, when constructed, initializes the dependent libraries (e.g.
Definition: libmesh.h:83
libMesh::MeshBase::all_first_order
virtual void all_first_order()=0
Converts a mesh with higher-order elements into a mesh with linear elements.
libMesh::MeshTools::Modification::distort
void distort(MeshBase &mesh, const Real factor, const bool perturb_boundary=false)
Randomly perturb the nodal locations.
Definition: mesh_modification.C:65
libMesh::ElemQuality
ElemQuality
Defines an enum for element quality metrics.
Definition: enum_elem_quality.h:34
libMesh::MeshTools::Modification::all_tri
void all_tri(MeshBase &mesh)
Converts the 2D quadrilateral elements of a Mesh into triangular elements.
Definition: mesh_modification.C:280
libMesh::MeshBase::print_info
void print_info(std::ostream &os=libMesh::out) const
Prints relevant information about the mesh.
Definition: mesh_base.C:585
BM_MESH_ONLY
Definition: meshtool.C:53
libMesh::StatisticsVector
The StatisticsVector class is derived from the std::vector<> and therefore has all of its useful feat...
Definition: statistics.h:67
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition: libmesh_common.h:121
libMesh::out
OStreamProxy out
libMesh::MeshBase::active_elements_end
virtual element_iterator active_elements_end()=0
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::BoundaryInfo::sync
void sync(UnstructuredMesh &boundary_mesh)
Generates boundary_mesh data structures corresponding to the mesh data structures.
Definition: boundary_info.C:200
libMesh::MeshBase::partition
virtual void partition(const unsigned int n_parts)
Call the default partitioner (currently metis_partition()).
Definition: mesh_base.C:599
Generated on Sat Jan 25 2020 12:07:08 for libMesh by   doxygen 1.8.16