CESets.cpp

Go to the documentation of this file.

#include "meshkit/CESets.hpp"

#include <cassert>
#include <cstdlib>
#include <cstring>
#include <iMesh_extensions.h>

#include <meshkit/Error.hpp>

namespace MeshKit {

CESets::~CESets()
{
  std::vector<tag_data>::iterator i;
  for (i = tags_.begin(); i != tags_.end(); ++i)
    free(i->value);
}

void CESets::add_tag(iMesh::TagHandle tag_handle, const char *value)
{
  assert(tag_handle != NULL);
  char *tmp = NULL;

  if (value) {
    int tag_size;
    IBERRCHK(mesh_->getTagSizeBytes(tag_handle, tag_size), *mesh_);

    tmp = static_cast<char*>(malloc(tag_size));
    memcpy(tmp, value, tag_size);
  }

  tags_.push_back(tag_data(tag_handle, tmp));
}

void CESets::add_tag(const std::string &tag_name, const char *value)
{
  iMesh::TagHandle tag_handle;
  IBERRCHK(mesh_->getTagHandle(tag_name.c_str(), tag_handle), *mesh_);
  add_tag(tag_handle, value);
}

void CESets::update_tagged_sets()
{
  int err;
  iMesh::EntitySetHandle root_set = mesh_->getRootSet();

  std::vector<tag_data>::const_iterator tag;
  for (tag = tags_.begin(); tag != tags_.end(); ++tag) {
    iMesh::EntitySetHandle *tmp_sets = NULL;
    int tmp_sets_alloc = 0, tmp_sets_size;
    iMesh_getEntSetsByTagsRec(mesh_->instance(), root_set, &tag->tag,
                              (tag->value ? &tag->value : NULL), 1, false,
                              &tmp_sets, &tmp_sets_alloc, &tmp_sets_size, &err);
    IBERRCHK(err, *mesh_);
    sets_.insert(tmp_sets, tmp_sets+tmp_sets_size);
    free(tmp_sets);
  }
}

void link_expand_sets(const CESets &ce_sets, iMesh::TagHandle local_tag)
{
  CESets::set_iterator set;
  for (set = ce_sets.sbegin(); set != ce_sets.send(); ++set) {
    IBERRCHK(ce_sets.imesh_instance()->setEntSetESHData(*set, local_tag, *set),
             *ce_sets.imesh_instance());
  }
}

static
void get_copied_ents(iMesh *mesh, iMesh::EntitySetHandle set,
                     iMesh::TagHandle local_tag,
                     std::vector<iMesh::EntityHandle> &ents)
{
  std::vector<iMesh::EntityHandle> tmp_ents;
  IBERRCHK(mesh->getEntities(set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, 
                             tmp_ents), *mesh);

  ents.reserve(tmp_ents.size());

  // get copied entities
  for (size_t i = 0; i < tmp_ents.size(); i++) {
    iMesh::EntityHandle eh_tag;
    iMesh::Error err = mesh->getEHData(tmp_ents[i], local_tag, eh_tag);
    if (err == iBase_SUCCESS && eh_tag)
      ents.push_back(eh_tag);
  }
}

static
void get_dest_set(iMesh *mesh, iMesh::TagHandle local_tag,
                  iMesh::EntitySetHandle src, iMesh::EntitySetHandle &dest)
{
  iMesh::Error err;

  err = mesh->getEntSetESHData(src, local_tag, dest);

  if (err != iBase_SUCCESS) {
    IBERRCHK(mesh->createEntSet(false, dest), *mesh);
    IBERRCHK(mesh->setEntSetESHData(src, local_tag, dest), *mesh);
  }
}

static
void process_ce_subsets(iMesh *mesh, iMesh::EntitySetHandle src,
                        iMesh::EntitySetHandle current,
                        const std::set<iMesh::EntitySetHandle> &cesets,
                        iMesh::TagHandle local_tag) 
{
  iMesh::EntitySetHandle dest;

  // First, add entities directly contained in this set.
  std::vector<iMesh::EntityHandle> tmp_tags;
  get_copied_ents(mesh, current, local_tag, tmp_tags);

  if (!tmp_tags.empty()) {
    get_dest_set(mesh, local_tag, src, dest);
    IBERRCHK(mesh->addEntArrToSet(&tmp_tags[0], tmp_tags.size(), dest), *mesh);
  }

  // Next, start looking at children.
  std::vector<iMesh::EntitySetHandle> children;
  IBERRCHK(mesh->getEntSets(current, 0, children), *mesh);

  for (size_t i = 0; i < children.size(); i++) {

    // If this child set is one of our cesets, add just the set...
    if (cesets.find(children[i]) != cesets.end()) {
      get_dest_set(mesh, local_tag, src, dest);
      if (src == dest) continue;

      IBERRCHK(mesh->addEntSet(children[i], dest), *mesh);
    }

    // ... otherwise, add the entities and recurse into the next level of
    // children.
    else {
      process_ce_subsets(mesh, src, children[i], cesets, local_tag);
    }
  }
}

// xxx - still need to do unique tags
// - for each unique tag
//   . if this set has the tag, add/append to get unique value
void process_ce_sets(iMesh *mesh,
                     const std::set<iMesh::EntitySetHandle> &cesets,
                     iMesh::TagHandle local_tag) 
{
  std::set<iMesh::EntitySetHandle>::const_iterator src;
  for (src = cesets.begin(); src != cesets.end(); ++src)
    process_ce_subsets(mesh, *src, *src, cesets, local_tag);
}

void tag_copy_sets(iMesh *mesh, iMesh::TagHandle copyTag,
                   const std::set<iMesh::EntitySetHandle> &copySets,
                   iMesh::TagHandle tag, const char *tag_val)
{
  iMesh::Error err;

  int tag_size;
  IBERRCHK(mesh->getTagSizeBytes(tag, tag_size), *mesh);

  // allocate temp space for tag value
  std::vector<char> value(tag_size);
  
  // for each orig copy set with this tag, copy it to its copy
  std::set<iMesh::EntitySetHandle>::iterator set;
  for (set = copySets.begin(); set != copySets.end(); ++set) {
    // get the tag value
    err = mesh->getEntSetData(*set, tag, &value[0]);
    if (err == iBase_TAG_NOT_FOUND)
      continue;
    IBERRCHK(err, *mesh);

    // compare to tag value if necessary
    if (tag_val && strncmp(tag_val, &value[0], tag_size))
      continue;
      
    // if we got here, we should set the tag on the copy; get the copy
    iMesh::EntitySetHandle copy_set;
    err = mesh->getEntSetESHData(*set, copyTag, copy_set);
    if (err == iBase_TAG_NOT_FOUND)
      continue;
    IBERRCHK(err, *mesh);

    if (copy_set != *set)
      IBERRCHK(mesh->setEntSetData(copy_set, tag, &value[0]), *mesh);
  }
}

void tag_copy_sets(const CESets &ce_sets, iMesh::TagHandle local_tag,
                   iMesh::TagHandle copy_tag)
{
  // set the copy tag on all copied sets
  for (CESets::const_set_iterator set = ce_sets.sbegin(); set != ce_sets.send();
       ++set) {
    iMesh::Error err;
    iMesh::EntityHandle eh;
    err = ce_sets.imesh_instance()->getEntSetEHData(*set, local_tag, eh);
    if (err == iBase_SUCCESS) {
      IBERRCHK(ce_sets.imesh_instance()->setEntSetEHData(*set, copy_tag, eh),
               *ce_sets.imesh_instance());
    }
  }

  // tag the newly-created sets
  for (CESets::const_tag_iterator tag = ce_sets.tbegin();
       tag != ce_sets.tend(); ++tag) {
    tag_copy_sets(ce_sets.imesh_instance(), copy_tag, ce_sets.sets(),
                  tag->tag, tag->value);
  }
}

} // namespace MeshKit