Пример #1
0
    ErrorCode Tree::parse_common_options(FileOptions &options) 
    {
      double tmp_dbl;
      int tmp_int;
        // MAX_PER_LEAF: max entities per leaf; default = 6
      ErrorCode rval = options.get_int_option("MAX_PER_LEAF", tmp_int);
      if (MB_SUCCESS == rval) maxPerLeaf = std::max(tmp_int, 1);
      
        // MAX_DEPTH: max depth of the tree; default = 30
      rval = options.get_int_option("MAX_DEPTH", tmp_int);
      if (MB_SUCCESS == rval) maxDepth = tmp_int;
      if (maxDepth < 1) maxDepth = std::numeric_limits<unsigned>::max();

        // MIN_WIDTH: minimum width of box, used like a tolerance; default = 1.0e-10
      rval = options.get_real_option("MIN_WIDTH", tmp_dbl);
      if (MB_SUCCESS == rval) minWidth = tmp_dbl;

        // MESHSET_FLAGS: flags passed into meshset creation for tree nodes; should be a value from
        //          ENTITY_SET_PROPERTY (see Types.hpp); default = MESHSET_SET
      rval = options.get_int_option("MESHSET_FLAGS", tmp_int);
      if (MB_SUCCESS == rval && 0 <= tmp_int) meshsetFlags = (unsigned) tmp_int;
      else if (0 > tmp_int) return MB_FAILURE;

        // CLEAN_UP: if false, do not delete tree sets upon tree class destruction; default = true
      bool tmp_bool;
      rval = options.get_toggle_option("CLEAN_UP", true, tmp_bool);
      if (MB_SUCCESS == rval && !tmp_bool) cleanUp = false;

        // TAG_NAME: tag name to store tree information on tree nodes; default = "AKDTree"
      std::string tmp_str;
      rval = options.get_str_option("TAG_NAME", tmp_str);
      if (MB_SUCCESS == rval) boxTagName = tmp_str;

      return MB_SUCCESS;
    }
Пример #2
0
ErrorCode WriteVtk::write_file(const char *file_name,
                               const bool overwrite,
                               const FileOptions& opts,
                               const EntityHandle *output_list,
                               const int num_sets,
                               const std::vector<std::string>& /* qa_list */,
                               const Tag* tag_list,
                               int num_tags,
                               int /* export_dimension */)
{
  ErrorCode rval;

  // Get precision for node coordinates
  int precision;
  if (MB_SUCCESS != opts.get_int_option("PRECISION", precision))
    precision = DEFAULT_PRECISION;

  if (MB_SUCCESS == opts.get_null_option("STRICT"))
    mStrict = true;
  else if (MB_SUCCESS == opts.get_null_option("RELAXED"))
    mStrict = false;
  else
    mStrict = DEFAULT_STRICT;

  // Get entities to write
  Range nodes, elems;
  rval = gather_mesh(output_list, num_sets, nodes, elems);
  if (MB_SUCCESS != rval)
    return rval;

  // Honor overwrite flag
  if (!overwrite) {
    rval = writeTool->check_doesnt_exist(file_name);
    if (MB_SUCCESS != rval)
      return rval;
  }

  // Create file
  std::ofstream file(file_name);
  if (!file) {
    MB_SET_ERR(MB_FILE_WRITE_ERROR, "Could not open file: " << file_name);
  }
  file.precision(precision);

  // Write file
  if ((rval = write_header(file              )) != MB_SUCCESS ||
      (rval = write_nodes( file, nodes       )) != MB_SUCCESS ||
      (rval = write_elems( file, nodes, elems)) != MB_SUCCESS ||
      (rval = write_tags ( file, true,  nodes, tag_list, num_tags)) != MB_SUCCESS ||
      (rval = write_tags ( file, false, elems, tag_list, num_tags)) != MB_SUCCESS) {
    file.close();
    remove(file_name);
    return rval;
  }

  return MB_SUCCESS;
}
Пример #3
0
//! Writes out a file
ErrorCode WriteGmsh::write_file(const char *file_name,
                                const bool overwrite,
                                const FileOptions& options,
                                const EntityHandle *output_list,
                                const int num_sets,
                                const std::vector<std::string>& /* qa_list */,
                                const Tag* /* tag_list */,
                                int /* num_tags */,
                                int /* export_dimension */)
{
  ErrorCode rval;
  Tag global_id = 0, block_tag = 0, geom_tag = 0, prtn_tag = 0;

  if (!overwrite) {
    rval = mWriteIface->check_doesnt_exist(file_name);
    if (MB_SUCCESS != rval)
      return rval;
  }

  // Get tags
  mbImpl->tag_get_handle(GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, global_id);
  mbImpl->tag_get_handle(MATERIAL_SET_TAG_NAME, 1, MB_TYPE_INTEGER, block_tag);
  if (global_id) 
    mbImpl->tag_get_handle(GEOM_DIMENSION_TAG_NAME, 1, MB_TYPE_INTEGER, geom_tag);
  mbImpl->tag_get_handle(PARALLEL_PARTITION_TAG_NAME, 1, MB_TYPE_INTEGER, prtn_tag);

  // Define arrays to hold entity sets of interest
  Range sets[3];
  Tag set_tags[] = {block_tag, geom_tag, prtn_tag};
  Tag set_ids[] = {block_tag, 0 /*global_id*/, prtn_tag};

  // Get entities to write
  Range elements, nodes;
  if (!output_list) {
    rval = mbImpl->get_entities_by_dimension(0, 0, nodes, false);
    if (MB_SUCCESS != rval)
      return rval;
    for (int d = 1; d < 3; ++d) {
      Range tmp_range;
      rval = mbImpl->get_entities_by_dimension(0, d, tmp_range, false);
      if (MB_SUCCESS != rval)
        return rval;
      elements.merge(tmp_range);
    }

    for (int s = 0; s < 3; ++s) {
      if (set_tags[s]) {
        rval = mbImpl->get_entities_by_type_and_tag(0, MBENTITYSET, set_tags + s, 0, 1, sets[s]);
        if (MB_SUCCESS != rval)
          return rval;
      }
    }
  }
  else {
    for (int i = 0; i < num_sets; ++i) {
      EntityHandle set = output_list[i];
      for (int d = 1; d < 3; ++d) {
        Range tmp_range, tmp_nodes;
        rval = mbImpl->get_entities_by_dimension(set, d, tmp_range, true);
        if (rval != MB_SUCCESS)
          return rval;
        elements.merge(tmp_range);
        rval = mbImpl->get_adjacencies(tmp_range, set, false, tmp_nodes);
        if (rval != MB_SUCCESS)
          return rval;
        nodes.merge(tmp_nodes);
      }

      for (int s = 0; s < 3; ++s) {
        if (set_tags[s]) {
          Range tmp_range;
          rval = mbImpl->get_entities_by_type_and_tag(set, MBENTITYSET, set_tags + s, 0, 1, tmp_range);
          if (MB_SUCCESS != rval)
            return rval;
          sets[s].merge(tmp_range);
          int junk;
          rval = mbImpl->tag_get_data(set_tags[s], &set, 1, &junk);
          if (MB_SUCCESS == rval)
            sets[s].insert(set);
        }
      }
    }
  }

  if (elements.empty()) {
    MB_SET_ERR(MB_ENTITY_NOT_FOUND, "Nothing to write");
  }

  // Get global IDs for all elements.
  // First try to get from tag.  If tag is not defined or not set
  // for all elements, use handle value instead.
  std::vector<int> global_id_array(elements.size());
  std::vector<int>::iterator id_iter;
  if (!global_id || MB_SUCCESS !=
      mbImpl->tag_get_data(global_id, elements, &global_id_array[0])) {
    id_iter = global_id_array.begin();
    for (Range::iterator i = elements.begin(); i != elements.end(); ++i, ++id_iter)
      *id_iter = mbImpl->id_from_handle(*i);
  }

  // Figure out the maximum ID value so we know where to start allocating
  // new IDs when we encounter ID conflicts.
  int max_id = 0;
  for (id_iter = global_id_array.begin(); id_iter != global_id_array.end(); ++id_iter)
    if (*id_iter > max_id)
      max_id = *id_iter;

  // Initialize ElemInfo struct for each element
  std::map<EntityHandle, ElemInfo> elem_sets; // Per-element info
  std::set<int> elem_global_ids; // Temporary for finding duplicate IDs
  id_iter = global_id_array.begin();
  // Iterate backwards to give highest-dimension entities first dibs for
  // a conflicting ID.
  for (Range::reverse_iterator i = elements.rbegin(); i != elements.rend(); ++i) {
    int id = *id_iter;
    ++id_iter;
    if (!elem_global_ids.insert(id).second)
      id = max_id++;

    ElemInfo& ei = elem_sets[*i];
    ei.count = 0;
    ei.id = id;

    EntityType type = mbImpl->type_from_handle(*i);
    int num_vtx;
    const EntityHandle* conn;
    rval = mbImpl->get_connectivity(*i, conn, num_vtx);
    if (MB_SUCCESS != rval)
      return rval;

    ei.type = GmshUtil::get_gmsh_type(type, num_vtx);
    if (ei.type < 0) {
      MB_SET_ERR(MB_FILE_WRITE_ERROR, "Gmem file format does not support element of type " << CN::EntityTypeName(type) << " with " << num_vtx << " vertices");
    }
  }
  // Don't need these any more, free memory.
  elem_global_ids.clear();
  global_id_array.clear();

  // For each material set, geometry set, or partition; store
  // the ID of the set on each element.
  for (int s = 0; s < 3; ++s) {
    if (!set_tags[s])
      continue;

    for (Range::iterator i = sets[s].begin(); i != sets[s].end(); ++i) {
      int id;
      if (set_ids[s]) {
        rval = mbImpl->tag_get_data(set_ids[s], &*i, 1, &id);
        if (MB_SUCCESS != rval)
          return rval;
      }
      else
        id = mbImpl->id_from_handle(*i);

      Range elems;
      rval = mbImpl->get_entities_by_handle(*i, elems);
      if (MB_SUCCESS != rval)
        return rval;

      elems = intersect(elems, elements);
      for (Range::iterator j = elems.begin(); j != elems.end(); ++j)
        elem_sets[*j].set(s, id);
    }
  }

  // Create file
  std::ofstream out(file_name);
  if (!out)
    return MB_FILE_DOES_NOT_EXIST;

  // Write header
  out << "$MeshFormat" << std::endl;
  out << "2.0 0 " << sizeof(double) << std::endl;
  out << "$EndMeshFormat" << std::endl;

  // Set precision for node coordinates
  int precision;
  if (MB_SUCCESS != options.get_int_option("PRECISION", precision))
    precision = DEFAULT_PRECISION;
  const int old_precision = out.precision();
  out.precision(precision);

  // Write nodes
  out << "$Nodes" << std::endl;
  out << nodes.size() << std::endl;
  std::vector<double> coords(3*nodes.size());
  rval = mbImpl->get_coords(nodes, &coords[0]);
  if (MB_SUCCESS != rval)
    return rval;
  std::vector<double>::iterator c = coords.begin();
  for (Range::iterator i = nodes.begin(); i != nodes.end(); ++i) {
    out << mbImpl->id_from_handle(*i);
    out << " " << *c; ++c;
    out << " " << *c; ++c;
    out << " " << *c; ++c;
    out << std::endl;
  }
  out << "$EndNodes" << std::endl;
  coords.clear();

  // Restore stream state
  out.precision(old_precision);

  // Write elements
  out << "$Elements" << std::endl;
  out << elem_sets.size() << std::endl;
  for (std::map<EntityHandle, ElemInfo>::iterator i = elem_sets.begin();
       i != elem_sets.end(); ++i) {
    int num_vtx;
    const EntityHandle* conn;
    rval = mbImpl->get_connectivity(i->first, conn, num_vtx);
    if (MB_SUCCESS != rval)
      return rval;
    out << i->second.id << ' ' << i->second.type << ' ' << i->second.count;
    for (int j = 0; j < i->second.count; ++j)
      out << ' ' << i->second.sets[j];

    const int* order = GmshUtil::gmshElemTypes[i->second.type].node_order;

    // Need to re-order vertices
    if (order) {
      for (int j = 0; j < num_vtx; ++j)
        out << ' ' << mbImpl->id_from_handle(conn[order[j]]);
    }
    else {
      for (int j = 0; j < num_vtx; ++j)
        out << ' ' << mbImpl->id_from_handle(conn[j]);
    }
    out << std::endl;
  }
  out << "$EndElements" << std::endl;

  // Done
  return MB_SUCCESS;
}
Пример #4
0
ErrorCode ReadNC::parse_options(const FileOptions& opts, std::vector<std::string>& var_names, std::vector<int>& tstep_nums,
                                std::vector<double>& tstep_vals)
{
  int tmpval;
  if (MB_SUCCESS == opts.get_int_option("DEBUG_IO", 1, tmpval)) {
    dbgOut.set_verbosity(tmpval);
    dbgOut.set_prefix("NC ");
  }

  ErrorCode rval = opts.get_strs_option("VARIABLE", var_names);
  if (MB_TYPE_OUT_OF_RANGE == rval)
    noVars = true;
  else
    noVars = false;

  opts.get_ints_option("TIMESTEP", tstep_nums);
  opts.get_reals_option("TIMEVAL", tstep_vals);

  rval = opts.get_null_option("NOMESH");
  if (MB_SUCCESS == rval)
    noMesh = true;

  rval = opts.get_null_option("SPECTRAL_MESH");
  if (MB_SUCCESS == rval)
    spectralMesh = true;

  rval = opts.get_null_option("NO_MIXED_ELEMENTS");
  if (MB_SUCCESS == rval)
    noMixedElements = true;

  rval = opts.get_null_option("NO_EDGES");
  if (MB_SUCCESS == rval)
    noEdges = true;

  if (2 <= dbgOut.get_verbosity()) {
    if (!var_names.empty()) {
      std::cerr << "Variables requested: ";
      for (unsigned int i = 0; i < var_names.size(); i++)
        std::cerr << var_names[i];
      std::cerr << std::endl;
    }

    if (!tstep_nums.empty()) {
      std::cerr << "Timesteps requested: ";
      for (unsigned int i = 0; i < tstep_nums.size(); i++)
        std::cerr << tstep_nums[i];
      std::cerr << std::endl;
    }

    if (!tstep_vals.empty()) {
      std::cerr << "Time vals requested: ";
      for (unsigned int i = 0; i < tstep_vals.size(); i++)
        std::cerr << tstep_vals[i];
      std::cerr << std::endl;
    }
  }

  rval = opts.get_int_option("GATHER_SET", 0, gatherSetRank);
  if (MB_TYPE_OUT_OF_RANGE == rval) {
    MB_SET_ERR(rval, "Invalid value for GATHER_SET option");
  }

  rval = opts.get_int_option("TIMESTEPBASE", 0, tStepBase);
  if (MB_TYPE_OUT_OF_RANGE == rval) {
    MB_SET_ERR(rval, "Invalid value for TIMESTEPBASE option");
  }

  rval = opts.get_int_option("TRIVIAL_PARTITION_SHIFT", 1, trivialPartitionShift);
  if (MB_TYPE_OUT_OF_RANGE == rval) {
    MB_SET_ERR(rval, "Invalid value for TRIVIAL_PARTITION_SHIFT option");
  }

#ifdef MOAB_HAVE_MPI
  isParallel = (opts.match_option("PARALLEL", "READ_PART") != MB_ENTITY_NOT_FOUND);

  if (!isParallel)
  // Return success here, since rval still has _NOT_FOUND from not finding option
  // in this case, myPcomm will be NULL, so it can never be used; always check for isParallel 
  // before any use for myPcomm
    return MB_SUCCESS;

  int pcomm_no = 0;
  rval = opts.get_int_option("PARALLEL_COMM", pcomm_no);
  if (MB_TYPE_OUT_OF_RANGE == rval) {
    MB_SET_ERR(rval, "Invalid value for PARALLEL_COMM option");
  }
  myPcomm = ParallelComm::get_pcomm(mbImpl, pcomm_no);
  if (0 == myPcomm) {
    myPcomm = new ParallelComm(mbImpl, MPI_COMM_WORLD);
  }
  const int rank = myPcomm->proc_config().proc_rank();
  dbgOut.set_rank(rank);

  int dum;
  rval = opts.match_option("PARTITION_METHOD", ScdParData::PartitionMethodNames, dum);
  if (MB_FAILURE == rval) {
    MB_SET_ERR(rval, "Unknown partition method specified");
  }
  else if (MB_ENTITY_NOT_FOUND == rval)
    partMethod = ScdParData::ALLJORKORI;
  else
    partMethod = dum;
#endif

  return MB_SUCCESS;
}