12int main(
int argc, 
char *argv[]) {
 
   17    moab::Core mb_instance;
 
   18    moab::Interface &moab = mb_instance;
 
   19    ParallelComm *pcomm = ParallelComm::get_pcomm(&moab, 
MYPCOMM_INDEX);
 
   21      pcomm = 
new ParallelComm(&moab, PETSC_COMM_WORLD);
 
   23    char mesh_out_file[255] = 
"out.h5m";
 
   25    char meshset_to_write[255] = 
"";
 
   26    PetscBool meshset_to_write_set = PETSC_FALSE;
 
   31    PetscBool bit_ref_set = PETSC_FALSE;
 
   32    int bit_ref_level = 0;
 
   34    PetscOptionsBegin(m_field.
get_comm(), 
"", 
"Read MED tool", 
"none");
 
   37    CHKERR PetscOptionsInt(
"-bit_ref_level", 
"bit ref level", 
"", bit_ref_level,
 
   38                           &bit_ref_level, &bit_ref_set);
 
   40                                 meshset_to_write, 255, &meshset_to_write_set);
 
   41    CHKERR PetscOptionsInt(
"-med_time_step", 
"time step", 
"", time_step,
 
   42                           &time_step, PETSC_NULLPTR);
 
   43    CHKERR PetscOptionsString(
"-output_file", 
"output mesh file name", 
"",
 
   44                              "out.h5m", mesh_out_file, 255, PETSC_NULLPTR);
 
   47    const char *option = 
"";
 
   56    Range entities_to_write;
 
   61      bit_level.set(bit_ref_level);
 
   68      entities_to_write = subtract(entities_to_write,
 
   69                                   entities_to_write.subset_by_type(MBPRISM));
 
   72          subtract(entities_to_write, entities_to_write.subset_by_type(MBQUAD));
 
   74          << 
"Total number of entities in bit ref level " << bit_ref_level
 
   75          << 
": " << entities_to_write.size() << std::endl;
 
   78          << 
"Removing interior edges and face entities"<< std::endl;
 
   80      Range entities_3d = entities_to_write.subset_by_dimension(3);
 
   81      Range entities_2d = entities_to_write.subset_by_dimension(2);
 
   82      Range entities_1d = entities_to_write.subset_by_dimension(1);
 
   88      CHKERR skin.find_skin(0, entities_3d, 
false, skin_2d);
 
   89      CHKERR moab.get_adjacencies(skin_2d, 1, 
false, skin_1d,
 
   90                                  moab::Interface::UNION);
 
   93      entities_2d = subtract(entities_2d, skin_2d);
 
   94      entities_to_write = subtract(entities_to_write, entities_2d);
 
   96      entities_1d = subtract(entities_1d, skin_1d);
 
   97      entities_to_write = subtract(entities_to_write, entities_1d);
 
  100          << 
"Removing nodes with no connectivity"<< std::endl;
 
  104      nodes = entities_to_write.subset_by_type(MBVERTEX);
 
  107      for (
auto node : nodes) {
 
  110        CHKERR moab.get_adjacencies(&node_handle, 1, 1, 
false, adj_edges,
 
  111                                    moab::Interface::UNION);
 
  112        if (adj_edges.empty()) {
 
  113          free_nodes.insert(node);
 
  117      for (
auto node : free_nodes) {
 
  119        CHKERR moab.get_coords(&node, 1, coords);
 
  123      entities_to_write = subtract(entities_to_write, free_nodes);
 
  135      Range entities_10000;
 
  136      Range entities_10001;
 
  137      moab.get_entities_by_handle(meshset_10000, entities_10000);
 
  138      moab.get_entities_by_handle(meshset_10001, entities_10001);
 
  140      auto check_face_orientation = [&moab](
const Range &faces) {
 
  141        for (
auto face : faces) {
 
  145          CHKERR(moab.get_adjacencies(&face, 1, 3, 
false, adj_tets,
 
  146                                      moab::Interface::UNION));
 
  149          actual_tets = adj_tets.subset_by_type(MBTET);
 
  154          for (
auto tet : actual_tets) {
 
  155            CHKERR(moab.side_number(tet, face, side_number, sense, offset));
 
  158              std::vector<EntityHandle> nodes_face;
 
  159              CHKERR(moab.get_connectivity(&face, 1, nodes_face));
 
  160              std::vector<EntityHandle> face_nodes_new;
 
  162              face_nodes_new = {nodes_face[1], nodes_face[0], nodes_face[2]};
 
  163              CHKERR(moab.set_connectivity(face, face_nodes_new.data(), 3));
 
  165              CHKERR(moab.side_number(tet, face, side_number, sense, offset));
 
  168                    << 
"Face: " << face << 
" has wrong orientation";
 
  175      check_face_orientation(entities_10000);
 
  176      check_face_orientation(entities_10001);
 
  178    } 
else if (meshset_to_write_set) {
 
  183      for (
auto &meshset : meshsets_idx) {
 
  184        auto meshset_name = meshset.getName();
 
  185        auto trim_name = [&](std::string &name) {
 
  186          name.erase(std::remove(name.begin(), name.end(), 
' '), name.end());
 
  188        trim_name(meshset_name);
 
  190        if (meshset_to_write == meshset_name) {
 
  191          CHKERR moab.get_entities_by_handle(meshset.getMeshset(),
 
  192                                             entities_to_write, 
true);
 
  197          << 
"Wrtiting all entitiies from meshset: " << meshset_to_write
 
  201      CHKERR moab.get_entities_by_handle(0, entities_to_write, 
true);
 
  203          << 
"Wrtiting all entitiies" << std::endl;
 
  206        << 
"Number of entities to write: " << entities_to_write.size()
 
  209    for (EntityType ent_type = MBVERTEX; ent_type < MBMAXTYPE; ent_type++) {
 
  211      moab.get_entities_by_type(0, ent_type, entities, 
true);
 
  213      ents_to_write = intersect(entities, entities_to_write);
 
  215      if (ents_to_write.empty())
 
  219          << 
"Number of entities to write: " << ents_to_write.size()
 
  220          << 
" of type: " << moab::CN::EntityTypeName(ent_type)
 
  221          << 
" from total of: " << entities.size() << std::endl;
 
  225    boost::shared_ptr<Range> entities_to_write_ptr =
 
  226        boost::make_shared<Range>(entities_to_write);