124 #include "rheolef/compiler.h"
138 base::operator[](0) = x0;
139 base::operator[](1) = x1;
140 base::operator[](2) = x2;
171 #include "reference_element_aux.icc"
194 struct geo_element_side: std::array<size_t,4> {
195 void setname (
char name) { _variant = reference_element_variant(
name); }
196 void setindex (
size_t index) { _index = index; }
198 size_t index()
const {
return _index; }
199 size_t variant()
const {
return _variant; }
200 size_t dimension()
const {
return reference_element_dimension_by_variant(
variant()); }
201 size_t n_vertex()
const {
return reference_element_n_vertex (
variant()); }
202 size_t size()
const {
return n_vertex(); }
204 : array<size_t,4>(), _variant(-1), _index(-1)
239 size_t variant()
const {
return reference_element_variant (
name()); }
240 size_t dimension()
const {
return reference_element_dimension_by_name(
name()); }
245 size_t edge (
size_t i)
const {
return _edge[i].index(); }
247 size_t face (
size_t i)
const {
return _face[i].index(); }
259 array<geo_element_indirect,12>
_edge;
260 array<geo_element_indirect,6>
_face;
272 default:
error_macro (
"invalid variant");
return 0;
284 default:
error_macro (
"invalid variant");
return 0;
296 default:
error_macro (
"invalid variant");
return 0;
315 const array<size_t,reference_element__max_variant>& size_by_variant,
316 const array<size_t,reference_element__max_variant+1>& first_by_variant,
317 const array<size_t,reference_element__max_variant>& loc_ndof_by_variant,
319 vector<size_t>& dis_idof1)
321 dis_idof1.resize (reference_element_n_node (K.
variant(),
order));
322 std::fill (dis_idof1.begin(), dis_idof1.end(), std::numeric_limits<size_t>::max());
324 for (
size_t subgeo_variant = 0,
variant = K.
variant(); subgeo_variant <=
variant; subgeo_variant++) {
325 size_t subgeo_dim = reference_element_dimension_by_variant (subgeo_variant);
326 size_t loc_sub_ndof = loc_ndof_by_variant [subgeo_variant];
327 for (
size_t first_loc_idof = reference_element_first_inod_by_variant (
variant,
order, subgeo_variant),
328 last_loc_idof = reference_element_last_inod_by_variant (
variant,
order, subgeo_variant),
329 loc_idof = first_loc_idof;
330 loc_idof < last_loc_idof; loc_idof++) {
332 size_t loc_igev = (loc_idof - first_loc_idof) / loc_sub_ndof;
333 size_t loc_igev_j = (loc_idof - first_loc_idof) % loc_sub_ndof;
336 switch (subgeo_dim) {
339 size_t loc_inod = loc_idof;
344 loc_igev_j = geo_element_fix_edge_indirect (K, loc_igev, loc_igev_j,
order);
345 size_t loc_ige = loc_igev;
350 size_t loc_ige = loc_igev;
351 if (subgeo_variant == reference_element__t) {
352 loc_igev_j = geo_element_fix_triangle_indirect (K, loc_igev, loc_igev_j,
order);
354 size_t loc_ntri = (K.
variant() == reference_element__P) ? 2 : 0;
356 loc_igev_j = geo_element_fix_quadrangle_indirect (K, loc_ige, loc_igev_j,
order);
358 ige = K.
face(loc_ige);
366 error_macro (
"unexpected subgeo_dim="<<subgeo_dim);
371 for (
size_t prev_subgeo_variant = reference_element_first_variant_by_dimension(subgeo_dim);
372 prev_subgeo_variant < subgeo_variant;
373 prev_subgeo_variant++) {
374 size_t nprev = size_by_variant [prev_subgeo_variant];
378 size_t dis_igev = igev;
381 for (
size_t prev_subgeo_variant = 0;
382 prev_subgeo_variant < subgeo_variant;
383 prev_subgeo_variant++) {
384 dis_idof += size_by_variant [prev_subgeo_variant]
385 *loc_ndof_by_variant [prev_subgeo_variant];
388 *loc_ndof_by_variant [subgeo_variant]
390 assert_macro (loc_idof < dis_idof1.size(),
"msh2geo: invalid index");
400 const map<
size_t,list<size_t> >& domain_map,
401 map<size_t, string>& phys,
402 const vector<geo_element>& element)
404 if (
dim == dom_dim && domain_map.size() == 1)
return;
406 first = domain_map.begin(),
407 last = domain_map.end(); first != last; first++) {
408 size_t dom_idx = (*first).first;
409 const list<size_t>& dom = (*first).second;
410 string dom_name = phys[dom_idx];
411 if (dom_name ==
"") dom_name =
"unnamed" +
itos(dom_idx);
412 out <<
"domain" << endl
414 <<
"1 " << dom_dim <<
" " << dom.size() << endl;
415 for (
size_t variant = reference_element_first_variant_by_dimension(dom_dim);
416 variant < reference_element_last_variant_by_dimension(dom_dim);
variant++) {
417 for (list<size_t>::const_iterator fe = dom.begin(), le = dom.end(); fe != le; fe++) {
420 out << element[ie].name() <<
"\t";
421 if (element[ie].
order() > 1) {
422 out <<
"p" << element[ie].order() <<
" ";
424 for (
size_t j = 0; j < element[ie].size(); j++) {
425 out << element[ie][j] <<
" ";
438 const map<
size_t,list<size_t> >& domain_map,
439 map<size_t, string>& phys,
440 const vector<geo_element>& element,
441 const vector<geo_element_side>&
edge,
442 const vector<index_set>& edge_ball,
443 const vector<geo_element_side>&
face,
444 const vector<index_set>& face_ball)
446 if (
dim == dom_dim && domain_map.size() == 1)
return;
448 first = domain_map.begin(),
449 last = domain_map.end(); first != last; first++) {
450 size_t dom_idx = (*first).first;
451 const list<size_t>& dom = (*first).second;
452 string dom_name = phys[dom_idx];
453 if (dom_name ==
"") dom_name =
"unnamed" +
itos(dom_idx);
454 out <<
"domain" << endl
456 <<
"2 " << dom_dim <<
" " << dom.size() << endl;
457 for (
size_t variant = reference_element_first_variant_by_dimension(dom_dim);
458 variant < reference_element_last_variant_by_dimension(dom_dim);
variant++) {
459 for (list<size_t>::const_iterator fe = dom.begin(), le = dom.end(); fe != le; fe++) {
463 orientation_type orient = 1;
464 if (element[ie].
name() ==
'p') {
465 isid = element[ie][0];
467 }
else if (element[ie].
name() ==
'e') {
468 size_t inod0 = element[ie][0];
469 size_t inod1 = element[ie][1];
473 "msh2geo: error: connectivity problem (iedge.size="<<iedge_set.size()<<
")");
474 isid = *(iedge_set.begin());
475 orient = (inod0 ==
edge[isid][0]) ? 1 : -1;
476 }
else if (element[ie].
dimension() == 2) {
477 size_t inod0 = element[ie][0];
479 for (
size_t j = 1; j < element[ie].n_vertex(); ++j) {
480 size_t inodj = element[ie][j];
484 "msh2geo: error: connectivity problem (iface.size="<<iface_set.size()<<
")");
485 isid = *(iface_set.begin());
487 if (element[ie].
name() ==
't') {
488 geo_element_get_orientation_and_shift (
495 geo_element_get_orientation_and_shift (
504 isid = element[ie].index();
507 out << orient*int(isid) << endl;
513 void msh2geo (istream& in, ostream&
out,
string sys_coord_name,
bool do_upgrade)
520 "msh2geo: input stream does not contains a gmsh mesh file ($MeshFormat not found).");
521 double gmsh_fmt_version;
522 size_t file_type, float_data_size;
523 in >> gmsh_fmt_version >> file_type >> float_data_size;
525 "gmsh format version " << gmsh_fmt_version <<
" founded ; expect version 2.2 (HINT: use gmsh -format msh2)");
526 check_macro (file_type == 0,
"msh2geo: unsupported gmsh non-ascii format");
527 check_macro (
scatch(in,
"$EndMeshFormat",
true),
"msh2geo: gmsh input error: $EndMeshFormat not found.");
531 bool full_match =
true;
532 bool partial_match = !full_match;
533 check_macro (
scatch(in,
"$",partial_match),
"msh2geo: gmsh input error: no more label found.");
535 map<size_t, string> phys;
539 if (label ==
"PhysicalNames") {
541 for (
size_t i = 0; i < nphys; i++) {
543 size_t dom_dim, dom_idx;
544 in >> dom_dim >> dom_idx;
548 if (
c !=
'"')
name.push_back(
c);
552 }
while (
c !=
'"' &&
c !=
'\n');
554 size_t start = 0, end =
name.length();
555 if (
name[start] ==
'"') start++;
556 if (
name[end-1] ==
'"') end--;
557 name =
name.substr(start,end-start);
559 for (
size_t i = 0; i <
name.size(); i++) {
562 phys[dom_idx] =
name.substr(start,end-start);
564 check_macro (
scatch(in,
"$EndPhysicalNames",
true),
"msh2geo: gmsh input error ($EndPhysicalNames not found).");
565 check_macro (
scatch(in,
"$",partial_match),
"msh2geo: gmsh input error: no more label found.");
571 if (label !=
"Nodes") {
572 check_macro (
scatch(in,
"$Nodes",
true),
"msh2geo: $Nodes not found in gmsh file");
576 vector<point> node (nnode);
577 double infty = numeric_limits<double>::max();
578 point xmin ( infty, infty, infty);
579 point xmax (-infty, -infty, -infty);
580 for (
size_t k = 0; k < node.size(); k++) {
583 for (
size_t i = 0; i < 3; ++i) {
586 for (
size_t j = 0 ; j < 3; j++) {
587 xmin[j] = min(node[k][j], xmin[j]);
588 xmax[j] = max(node[k][j], xmax[j]);
595 if (xmax[2] == xmin[2]) {
597 if (xmax[1] == xmin[1]) {
599 if (xmax[0] == xmin[0])
dim = 0;
605 check_macro (
scatch(in,
"$Elements",
true),
"msh2geo: $Elements not found in gmsh file");
608 vector<geo_element> element (n_element);
609 vector<size_t> node_subgeo_variant (node.size(), std::numeric_limits<size_t>::max());
610 array<map<size_t, list<size_t> >,4> domain_map;
613 for (
size_t i = 0; i < element.size(); i++) {
614 size_t id, dummy, gmshtype;
615 in >>
id >> gmshtype;
618 size_t domain_idx = 0;
619 for (
size_t j = 0 ; j < n_tag_gmsh; j++) {
626 domain_idx = tag_dummy;
630 "msh2geo: element #" <<
id <<
": unexpected gmsh type '" << gmshtype <<
"'");
632 "msh2geo: element #" <<
id <<
": unsupported gmsh type '" << gmshtype <<
"'");
634 element[i].setname (gmsh_table[gmshtype].
name);
635 element[i].setorder(gmsh_table[gmshtype].
order);
636 element[i].setgmshtype(gmshtype);
637 size_t nv = gmsh_table[gmshtype].nv;
638 size_t nn = gmsh_table[gmshtype].nn_tot;
639 size_t dim_i = element[i].dimension();
640 size_t variant = element[i].variant();
643 order = element[i].order();
647 element[i].resize(
nn);
648 for (
size_t j = 0; j <
nn; j++) {
652 for (
size_t subgeo_variant = 0; subgeo_variant <=
variant; subgeo_variant++) {
653 for (
size_t loc_inod = reference_element_first_inod_by_variant(
variant,element[i].
order(),subgeo_variant),
654 loc_nnod = reference_element_last_inod_by_variant(
variant,element[i].
order(),subgeo_variant);
655 loc_inod < loc_nnod; loc_inod++) {
656 node_subgeo_variant [element[i][loc_inod]] = subgeo_variant;
661 if (domain_idx != 0) {
662 domain_map[dim_i][domain_idx].push_back(i);
665 array<size_t,reference_element__max_variant> loc_ndof_by_variant;
666 reference_element_init_local_nnode_by_variant (
order, loc_ndof_by_variant);
668 size_t last_index = 0;
669 for (
size_t variant = reference_element_first_variant_by_dimension(
map_dim);
671 for (
size_t ie = 0; ie < element.size(); ++ie) {
673 element[ie].setindex (last_index);
675 case 0: element[ie].resize(1); element[ie][0] = last_index;
break;
676 case 1: element[ie].edge_indirect(0).setindex(last_index);
break;
677 case 2: element[ie].face_indirect(0).setindex(last_index);
break;
687 vector<size_t> old2new_inode (node.size(), std::numeric_limits<size_t>::max());
688 if (
true || !do_upgrade) {
690 size_t new_inode = 0;
691 for (
size_t subgeo_variant = 0; subgeo_variant < reference_element_last_variant_by_dimension(
map_dim); subgeo_variant++) {
692 for (
size_t old_inode = 0; old_inode < node.size(); old_inode++) {
693 if (node_subgeo_variant [old_inode] != subgeo_variant)
continue;
694 old2new_inode[old_inode] = new_inode++;
699 for (
size_t inode = 0; inode < node.size(); inode++) {
700 old2new_inode[inode] = inode;
703 for (
size_t inode = 0; inode < node.size(); inode++) {
704 check_macro (old2new_inode[inode] != std::numeric_limits<size_t>::max(),
"msh2geo: invalid permutation");
707 vector<size_t> new2old_inode (node.size(), std::numeric_limits<size_t>::max());
708 for (
size_t inode = 0; inode < node.size(); inode++) {
709 new2old_inode[old2new_inode[inode]] = inode;
711 for (
size_t inode = 0; inode < node.size(); inode++) {
712 check_macro (new2old_inode[inode] != std::numeric_limits<size_t>::max(),
"msh2geo: invalid inverse permutation for inode="<<inode);
716 vector<point> new_node (node.size());
717 for (
size_t old_inode = 0; old_inode < node.size(); old_inode++) {
718 new_node [old2new_inode[old_inode]] = node [old_inode];
720 for (
size_t inode = 0; inode < node.size(); inode++) {
721 node [inode] = new_node [inode];
724 for (
size_t ie = 0; ie < element.size(); ++ie) {
725 for (
size_t i = 0; i < element[ie].size(); ++i) {
726 element[ie][i] = old2new_inode[element[ie][i]];
732 vector<index_set> edge_ball (node.size());
733 vector<geo_element_side>
edge;
734 if (do_upgrade &&
map_dim >= 2) {
735 list <geo_element_side> edge_list;
737 for (
size_t ie = 0; ie < element.size(); ++ie) {
739 for (
size_t iedg = 0; iedg < element[ie].n_edge(); ++iedg) {
740 size_t iv0 = element[ie].edge_local_vertex(iedg, 0);
741 size_t iv1 = element[ie].edge_local_vertex(iedg, 1);
742 size_t inod0 = element[ie][iv0];
743 size_t inod1 = element[ie][iv1];
747 "msh2geo: error: connectivity problem (iedge.size="<<iedge_set.size()<<
")");
748 if (iedge_set.size() == 1)
continue;
749 edge_ball[inod0].insert (nedg);
750 edge_ball[inod1].insert (nedg);
751 geo_element_side new_edge;
752 new_edge.setname(
'e');
755 new_edge.setindex(nedg);
756 edge_list.push_back (new_edge);
760 edge.resize (edge_list.size());
761 std::copy (edge_list.begin(), edge_list.end(),
edge.begin());
764 if (do_upgrade &&
map_dim >= 2) {
765 for (
size_t ie = 0; ie < element.size(); ++ie) {
767 for (
size_t iedg = 0; iedg < element[ie].n_edge(); ++iedg) {
768 size_t iv0 = element[ie].edge_local_vertex(iedg, 0);
769 size_t iv1 = element[ie].edge_local_vertex(iedg, 1);
770 size_t inod0 = element[ie][iv0];
771 size_t inod1 = element[ie][iv1];
775 "msh2geo: error: connectivity problem (iedge.size="<<iedge_set.size()<<
")");
776 size_t iedge = *(iedge_set.begin());
777 element[ie].edge_indirect(iedg).setindex (iedge);
778 element[ie].edge_indirect(iedg).setorientation((
edge[iedge][0] == inod0) ? 1 : -1);
785 vector<index_set> face_ball (node.size());
786 vector<geo_element_side>
face;
787 if (do_upgrade &&
map_dim >= 3) {
788 list <geo_element_side> face_list;
790 for (
size_t ie = 0; ie < element.size(); ++ie) {
792 for (
size_t loc_ifac = 0; loc_ifac < element[ie].n_face(); ++loc_ifac) {
793 size_t iv0 = element[ie].face_local_vertex(loc_ifac, 0);
794 size_t inod0 = element[ie][iv0];
796 for (
size_t j = 1; j < element[ie].face_n_vertex(loc_ifac); ++j) {
797 size_t ivj = element[ie].face_local_vertex(loc_ifac, j);
798 size_t inodj = element[ie][ivj];
802 "msh2geo: error: connectivity problem (iface.size="<<iface_set.size()<<
")");
803 if (iface_set.size() == 1)
continue;
804 geo_element_side new_face;
805 char face_name = (element[ie].face_n_vertex(loc_ifac) == 3) ?
't' :
'q';
806 new_face.setname(face_name);
807 new_face.setindex(nfac);
808 for (
size_t j = 0; j < element[ie].face_n_vertex(loc_ifac); ++j) {
809 size_t ivj = element[ie].face_local_vertex(loc_ifac, j);
810 size_t inodj = element[ie][ivj];
811 face_ball[inodj].insert (nfac);
814 face_list.push_back (new_face);
818 face.resize (face_list.size());
819 std::copy (face_list.begin(), face_list.end(),
face.begin());
822 if (do_upgrade &&
map_dim >= 3) {
823 for (
size_t ie = 0; ie < element.size(); ++ie) {
825 for (
size_t loc_ifac = 0; loc_ifac < element[ie].n_face(); ++loc_ifac) {
826 size_t iv0 = element[ie].face_local_vertex(loc_ifac, 0);
827 size_t inod0 = element[ie][iv0];
829 for (
size_t j = 1; j < element[ie].face_n_vertex(loc_ifac); ++j) {
830 size_t ivj = element[ie].face_local_vertex(loc_ifac, j);
831 size_t inodj = element[ie][ivj];
835 "msh2geo: error: connectivity problem (iface.size="<<iface_set.size()<<
")");
836 size_t iface = *(iface_set.begin());
837 orientation_type orient;
839 if (element[ie].face_n_vertex(loc_ifac) == 3) {
840 geo_element_get_orientation_and_shift (
842 element[ie][element[ie].face_local_vertex(loc_ifac, 0)],
843 element[ie][element[ie].face_local_vertex(loc_ifac, 1)],
844 element[ie][element[ie].face_local_vertex(loc_ifac, 2)],
847 geo_element_get_orientation_and_shift (
849 element[ie][element[ie].face_local_vertex(loc_ifac, 0)],
850 element[ie][element[ie].face_local_vertex(loc_ifac, 1)],
851 element[ie][element[ie].face_local_vertex(loc_ifac, 2)],
852 element[ie][element[ie].face_local_vertex(loc_ifac, 3)],
855 element[ie].face_indirect(loc_ifac).setindex (iface);
856 element[ie].face_indirect(loc_ifac).setorientation (orient);
857 element[ie].face_indirect(loc_ifac).setshift (shift);
864 array<size_t,reference_element__max_variant> size_by_variant;
865 array<size_t,reference_element__max_variant+1> first_by_variant;
866 size_by_variant.fill (0);
867 first_by_variant.fill (0);
870 for (
size_t inode = 0; inode < node.size(); inode++) {
871 if (node_subgeo_variant [inode] == reference_element__p)
n_vertex++;
873 size_by_variant [reference_element__p] =
n_vertex;
875 size_by_variant [reference_element__e] =
edge.size();
878 for (
size_t loc_ifac = 0; loc_ifac <
face.size(); ++loc_ifac) {
879 size_by_variant [
face[loc_ifac].variant()]++;
882 for (
size_t ie = 0; ie < element.size(); ++ie) {
884 size_t variant = element[ie].variant();
888 for (
size_t variant = reference_element_first_variant_by_dimension(
dim);
899 std::fill (old2new_inode.begin(), old2new_inode.end(), std::numeric_limits<size_t>::max());
900 std::fill (new2old_inode.begin(), new2old_inode.end(), std::numeric_limits<size_t>::max());
901 for (
size_t variant = reference_element_first_variant_by_dimension(
map_dim);
903 for (
size_t ie = 0; ie < element.size(); ++ie) {
906 std::vector<size_t> new_K;
908 order, size_by_variant, first_by_variant, loc_ndof_by_variant, old_K, new_K);
909 for (
size_t loc_inod = 0; loc_inod < old_K.
size(); loc_inod++) {
910 size_t old_inod = old_K [loc_inod];
911 size_t new_inod = new_K [loc_inod];
912 if (old2new_inode [old_inod] != std::numeric_limits<size_t>::max())
continue;
913 old2new_inode [old_inod] = new_inod;
919 for (
size_t inode = 0; inode < node.size(); inode++) {
920 old2new_inode[inode] = inode;
923 for (
size_t inode = 0; inode < node.size(); inode++) {
924 check_macro (old2new_inode[inode] != std::numeric_limits<size_t>::max(),
"msh2geo: invalid permutation");
927 for (
size_t inode = 0; inode < node.size(); inode++) {
928 new2old_inode[old2new_inode[inode]] = inode;
930 for (
size_t inode = 0; inode < node.size(); inode++) {
931 check_macro (new2old_inode[inode] != std::numeric_limits<size_t>::max(),
"msh2geo: invalid inverse permutation for inode="<<inode);
940 static const char* geo_variant_name [reference_element__max_variant] = {
949 out << setprecision(numeric_limits<double>::digits10)
955 <<
" dimension\t" <<
dim << endl;
956 if (sys_coord_name !=
"cartesian") {
957 out <<
" coordinate_system " << sys_coord_name << endl;
960 out <<
" order\t\t" <<
order << endl;
962 out <<
" nodes\t\t" << node.size() << endl;
965 for (
size_t variant = reference_element_first_variant_by_dimension(
map_dim);
967 if (size_by_variant[
variant] > 0) {
968 out <<
" " << geo_variant_name [
variant] <<
"\t" << size_by_variant[
variant] << endl;
972 if (
map_dim >= 3 && size_by_variant[reference_element__t] != 0) {
973 out <<
" triangles\t" << size_by_variant[reference_element__t] << endl;
975 if (
map_dim >= 3 && size_by_variant[reference_element__q] != 0) {
976 out <<
" quadrangles\t" << size_by_variant[reference_element__q] << endl;
978 if (
map_dim >= 2 && size_by_variant[reference_element__e] != 0) {
979 out <<
" edges\t" << size_by_variant[reference_element__e] << endl;
981 out <<
"end header" << endl
984 for (
size_t inode = 0; inode < node.size(); inode++) {
985 for (
size_t i = 0; i <
dim; ++i) {
986 out << node[new2old_inode[inode]][i];
987 if (i+1 !=
dim)
out <<
" ";
993 for (
size_t variant = reference_element_first_variant_by_dimension(
map_dim);
995 for (
size_t ie = 0; ie < element.size(); ie++) {
998 if (element[ie].
name() !=
'e' || element[ie].order() > 1) {
999 out << element[ie].name() <<
"\t";
1001 if (element[ie].
order() > 1) {
1002 out <<
"p" << element[ie].order() <<
" ";
1004 for (
size_t iloc = 0, nloc = element[ie].size(); iloc < nloc; iloc++) {
1005 out << element[ie][iloc];
1006 if (iloc+1 != nloc)
out <<
" ";
1010 out << element[ie].name() <<
"\t";
1011 for (
size_t iloc = 0, nloc = element[ie].
n_vertex(); iloc < nloc; iloc++) {
1012 out << element[ie][iloc];
1013 if (iloc+1 != nloc)
out <<
" ";
1021 for (
size_t variant = reference_element_first_variant_by_dimension(2);
1022 variant < reference_element_last_variant_by_dimension(2);
variant++) {
1023 for (
size_t ie = 0; ie <
face.size(); ie++) {
1025 out <<
face[ie].name() <<
"\t";
1026 for (
size_t iloc = 0, nloc =
face[ie].
n_vertex(); iloc < nloc; iloc++) {
1028 if (iloc+1 != nloc)
out <<
" ";
1034 for (
size_t ie = 0, ne =
edge.size(); ie < ne; ++ie) {
1035 out <<
"e\t" << old2new_inode[
edge[ie][0]]
1036 <<
" " << old2new_inode[
edge[ie][1]] << endl;
1042 for (
size_t d = 0;
d <= 3; ++
d) {
1053 cerr <<
"msh2geo: usage:" << endl
1054 <<
"msh2geo [-[no]upgrade][-rz|-zr] in.msh > out.geo" << endl
1055 <<
"msh2geo [-[no]upgrade][-rz|-zr] < in.msh > out.geo" << endl;
1062 string input_filename =
"";
1063 std::string sys_coord_name =
"cartesian";
1064 bool do_upgrade =
true;
1065 for (
int i = 1; i < argc; i++) {
1066 if (strcmp (argv[i],
"-rz") == 0) sys_coord_name =
"rz";
1067 else if (strcmp (argv[i],
"-zr") == 0) sys_coord_name =
"zr";
1068 else if (strcmp (argv[i],
"-cartesian") == 0) sys_coord_name =
"cartesian";
1069 else if (strcmp (argv[i],
"-upgrade") == 0) do_upgrade =
true;
1070 else if (strcmp (argv[i],
"-noupgrade") == 0) do_upgrade =
false;
1071 else if (argv[i][0] ==
'-') {
1072 cerr <<
"field: unknown option `" << argv[i] <<
"'" << endl;
1075 input_filename = argv[i];
1078 if (input_filename ==
"") {
1079 msh2geo (cin, cout, sys_coord_name, do_upgrade);
1081 ifstream fin (input_filename.c_str());
1083 cerr <<
"msh2geo: unable to read file \""<<input_filename<<
"\"" << endl; exit (1);
1085 msh2geo (fin, cout, sys_coord_name, do_upgrade);
see the edge page for the full documentation
see the hexahedron page for the full documentation
see the point page for the full documentation
see the prism page for the full documentation
see the quadrangle page for the full documentation
void setorientation(size_t orient)
void setindex(size_t index)
void setshift(size_t shift)
see the geo_element page for the full documentation
size_t face(size_t i) const
array< geo_element_indirect, 12 > _edge
const geo_element_indirect & edge_indirect(size_t i) const
geo_element_indirect & edge_indirect(size_t i)
void setindex(size_t index)
geo_element_indirect & face_indirect(size_t i)
size_t edge(size_t i) const
size_type face(size_type i) const
void setorder(size_t order)
size_t edge_local_vertex(size_t iedg, size_t edg_iv) const
void setgmshtype(size_t gmshtype)
array< geo_element_indirect, 6 > _face
size_t face_local_vertex(size_t iedg, size_t edg_iv) const
const geo_element_indirect & face_indirect(size_t i) const
size_t face_n_vertex(size_t loc_ifac) const
variant_type variant() const
const geo_element_indirect & edge_indirect(size_type i) const
void inplace_intersection(const index_set &b)
point_basic(T x0=T(), T x1=T(), T x2=T())
constexpr size_t reference_element__H
constexpr size_t reference_element__e
constexpr size_t reference_element__P
static size_t _reference_element_n_face_by_variant[reference_element__max_variant]
constexpr size_t reference_element__T
constexpr size_t reference_element__t
constexpr size_t reference_element__q
constexpr size_t reference_element__max_variant
static size_t _reference_element_n_edge_by_variant[reference_element__max_variant]
const char _reference_element_name[reference_element__max_variant]
see the tetrahedron page for the full documentation
see the triangle page for the full documentation
#define assert_macro(ok_condition, message)
#define error_macro(message)
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
hexahedron - reference element
const size_t face[n_face][4]
const size_t edge[n_edge][2]
void numbering_Pk_dis_idof(size_t order, const array< size_t, reference_element__max_variant > &size_by_variant, const array< size_t, reference_element__max_variant+1 > &first_by_variant, const array< size_t, reference_element__max_variant > &loc_ndof_by_variant, const geo_element &K, vector< size_t > &dis_idof1)
int main(int argc, char **argv)
void put_domain_noupgrade(ostream &out, size_t dim, size_t dom_dim, const map< size_t, list< size_t > > &domain_map, map< size_t, string > &phys, const vector< geo_element > &element)
void msh2geo(istream &in, ostream &out, string sys_coord_name, bool do_upgrade)
void put_domain_upgrade(ostream &out, size_t dim, size_t dom_dim, const map< size_t, list< size_t > > &domain_map, map< size_t, string > &phys, const vector< geo_element > &element, const vector< geo_element_side > &edge, const vector< index_set > &edge_ball, const vector< geo_element_side > &face, const vector< index_set > &face_ball)
void dis_idof(const basis_basic< T > &b, const geo_size &gs, const geo_element &K, typename std::vector< size_type >::iterator dis_idof_tab)
This file is part of Rheolef.
bool scatch(std::istream &in, const std::string &ch, bool full_match=true)
scatch: see the rheostream page for the full documentation
std::string itos(std::string::size_type i)
itos: see the rheostream page for the full documentation
void msh2geo_node_renum(vector< size_t > &element, size_t variant, size_t order)
prism - reference element
quadrangle - reference element
tetrahedron - reference element
triangle - reference element