21                                 {
   22 
   24 
   25  try {
   26 
   27    moab::Core mb_instance;
   28    moab::Interface &moab = mb_instance;
   29    ParallelComm *pcomm = ParallelComm::get_pcomm(&moab, 
MYPCOMM_INDEX);
 
   30    if (pcomm == NULL)
   31      pcomm = new ParallelComm(&moab, PETSC_COMM_WORLD);
   32 
   33    
   35    char mesh_out_file[255] = "out.h5m";
   36    PetscBool flg_file = PETSC_FALSE;
   37    PetscBool flg_n_part = PETSC_FALSE;
   38    PetscBool flg_part = PETSC_FALSE;
   39    PetscBool only_tags = PETSC_FALSE;
   40    PetscInt n_partas = 1;
   41    PetscBool create_lower_dim_ents = PETSC_TRUE;
   42    PetscInt dim = 3;
   43    PetscInt adj_dim = 0;
   44 
   45    PetscOptionsBegin(PETSC_COMM_WORLD, "", "none", "none");
   46 
   47    CHKERR PetscOptionsString(
"-my_file", 
"mesh file name", 
"", 
"mesh.h5m",
 
   49    if (flg_file != PETSC_TRUE)
   50      CHKERR PetscOptionsString(
"-file_name", 
"mesh file name", 
"", 
"mesh.h5m",
 
   52    if (flg_file != PETSC_TRUE)
   53      SETERRQ(PETSC_COMM_SELF, 1,
   54              "*** ERROR -my_file (-file_name) (mesh file needed)");
   55 
   56    const char *option;
   57    option = "";
   59 
   60    CHKERR PetscOptionsString(
"-output_file", 
"output mesh file name", 
"",
 
   61                              "out.h5m", mesh_out_file, 255, PETSC_NULLPTR);
   62    CHKERR PetscOptionsInt(
"-my_nparts", 
"number of parts", 
"", n_partas,
 
   63                           &n_partas, &flg_n_part);
   64    CHKERR PetscOptionsInt(
"-nparts", 
"number of parts", 
"", n_partas,
 
   65                           &n_partas, &flg_part);
   66 
   67    if (!flg_n_part && !flg_part)
   68      SETERRQ(PETSC_COMM_SELF, 1,
   69              "*** ERROR partitioning number not given (-nparts)");
   70 
   71    auto get_nb_ents_by_dim = [&](const int dim) {
   72      int nb;
   73      CHKERR moab.get_number_entities_by_dimension(0, dim, nb);
 
   74      return nb;
   75    };
   76    for (; dim >= 0; dim--) {
   77      if (get_nb_ents_by_dim(dim))
   78        break;
   79    }
   80 
   81    if (!dim)
   83              "Dimension of entities to partition not found");
   84 
   85    CHKERR PetscOptionsInt(
"-dim", 
"entities dim", 
"", dim, &dim, PETSC_NULLPTR);
 
   86    
   87    CHKERR PetscOptionsInt(
"-adj_dim", 
"adjacency dim", 
"", adj_dim, &adj_dim,
 
   88                           PETSC_NULLPTR);
   90        "-my_create_lower_dim_ents", "if true create lower dimension entireties",
   91        "", create_lower_dim_ents, &create_lower_dim_ents, PETSC_NULLPTR);
   92    CHKERR PetscOptionsBool(
"-block_tags", 
"only block and meshsests tags", 
"",
 
   93                            only_tags, &only_tags, PETSC_NULLPTR);
   94 
   95    PetscOptionsEnd();
   96 
   98      for (int d : {3, 2, 1})
   99        if (ents.num_of_dimension(d))
  100          return d;
  101      return 0;
  102    };
  103 
  104    
  107 
  110 
  113    int min_dim = 3;
  114    for (auto cit = meshsets_interface_ptr->getBegin();
  115         cit != meshsets_interface_ptr->getEnd(); cit++) {
  117      CHKERR m_field.
get_moab().get_entities_by_handle(cit->getMeshset(), ents,
 
  118                                                       true);
  119      min_dim = std::min(min_dim, 
get_dim(ents));
 
  121    }
  122 
  123    int g_dim; 
  124    MPI_Allreduce(&min_dim, &g_dim, 1, MPI_INT, MPI_MIN, m_field.
get_comm());
 
  125    if (g_dim < adj_dim) {
  127          << "The minimum meshsets dimension is = " << min_dim;
  128    }
  129    if (adj_dim >= dim) {
  131          << "The -adj_dim >= dim, adj_dim = " << adj_dim << " dim = " << dim;
  132    }
  134 
  135    {
  137      CHKERR moab.get_entities_by_dimension(0, dim, ents_dim, 
false);
 
  138      if (create_lower_dim_ents) {
  139        if (dim == 3) {
  141          CHKERR moab.get_adjacencies(ents_dim, 2, 
true, faces,
 
  142                                      moab::Interface::UNION);
  143        }
  144        if (dim > 2) {
  146          CHKERR moab.get_adjacencies(ents_dim, 1, 
true, edges,
 
  147                                      moab::Interface::UNION);
  148        }
  149      }
  152          ents_dim, dim, adj_dim, n_partas, 
nullptr, 
nullptr, 
nullptr, 
VERBOSE);
 
  153    }
  154 
  155    auto get_tag_list = [&]() {
  156      std::vector<Tag> tags_list;
  159      for (
auto &
m : list) {
 
  160        auto meshset = 
m.getMeshset();
 
  161        std::vector<Tag> tmp_tags_list;
  163                                                         tmp_tags_list);
  164        for (
auto t : tmp_tags_list) {
 
  165          tags_list.push_back(
t);
 
  166        }
  167      }
  168 
  169      return tags_list;
  170    };
  171 
  174      if (only_tags) {
  175        auto tags_list = get_tag_list();
  176        std::sort(tags_list.begin(), tags_list.end());
  177        auto new_end = std::unique(tags_list.begin(), tags_list.end());
  178        tags_list.resize(std::distance(tags_list.begin(), new_end));
  179        tags_list.push_back(pcomm->part_tag());
  180        
  181        CHKERR moab.write_file(mesh_out_file, 
"MOAB", 
"", &root_mesh, 1,
 
  182                               &*tags_list.begin(), tags_list.size());
  183      } else {
  184        CHKERR moab.write_file(mesh_out_file, 
"MOAB", 
"");
 
  185      }
  186      MOFEM_LOG(
"WORLD", Sev::inform) << 
"Wrote file " << mesh_out_file;
 
  187    }
  188  }
  190 
  193 
  194  return 0;
  195}
#define CATCH_ERRORS
Catch errors.
#define MYPCOMM_INDEX
default communicator number PCOMM
@ MOFEM_DATA_INCONSISTENCY
#define CHKERR
Inline error check.
#define MOFEM_LOG(channel, severity)
Log.
#define MOFEM_LOG_TAG(channel, tag)
Tag channel.
#define MOFEM_LOG_CHANNEL(channel)
Set and reset channel.
MoFEMErrorCode partitionMesh(const Range &ents, const int dim, const int adj_dim, const int n_parts, Tag *th_vertex_weights=nullptr, Tag *th_edge_weights=nullptr, Tag *th_part_weights=nullptr, int verb=VERBOSE, const bool debug=false)
Set partition tag to each finite element in the problem.
static MoFEMErrorCodeGeneric< PetscErrorCode > ierr
constexpr double t
plate stiffness
FTensor::Index< 'm', 3 > m
virtual moab::Interface & get_moab()=0
virtual MPI_Comm & get_comm() const =0
virtual int get_comm_rank() const =0
static MoFEMErrorCode Initialize(int *argc, char ***args, const char file[], const char help[])
Initializes the MoFEM database PETSc, MOAB and MPI.
static MoFEMErrorCode Finalize()
Checks for options to be called at the conclusion of the program.
Deprecated interface functions.
Interface for managing meshsets containing materials and boundary conditions.
CubitMeshSet_multiIndex & getMeshsetsMultindex()
MoFEMErrorCode setMeshsetFromFile(const string file_name, const bool clean_file_options=true)
add blocksets reading config file
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.