RefineVertex.h

Go to the documentation of this file.

#ifndef RefineVertex_HEADER
#define RefineVertex_HEADER

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include "MeshTypes.h"
#include <boost/array.hpp>
#include <geometry/Point.h>
#include <refine-common/ConcentricShells.h>
#include <utilities/FastHash.h>
#include <utilities/OrderedHash.h>
#include <utilities/foreach.h>
#include <vector>

#if 0
#define dprintf(...) printf(__VA_ARGS__);
#define dputs(str) puts(str);
#else
#define dprintf(...)
#define dputs(str)
#endif

/***************************************************************************
 * Vertex for use in the refinement.
 *
 * This collects:
 * -# a geometric point
 * -# the ID of the vertex
 * -# the containing dimension of the vertex
 * -# the set of meshes that contain the vertex
 *
 ***************************************************************************/

template <size_t ambient>
class RefineVertex : public boost::noncopyable {
  public:
  typedef Geometry::Point<ambient> Point;
  typedef ::GenericMesh<ambient> Mesh;
  typedef ::ConcentricShells<RefineVertex, Point> ConcentricShells;
  typedef typename MeshTypes<ambient>::Ball Ball;

  private:
  const Point p_;
  boost::array<std::vector<const Mesh*>, ambient> uppers_; // top-most is set to NULL
  typedef hudson::FastHashMap<const Mesh*, ConcentricShells, hudson::HashPointer<const Mesh> >
    Shells;
  Shells shells_;
  ConcentricShells topShell_;
  int id_; //<! id number
  int cd_; //<! containing dimension.  Constant.

  Ball *handle_; //<! a top-dimensional ball; any will do.  TODO: this should be a simplex

  public:

  typedef hudson::FastHashSet<RefineVertex*, hudson::HashPointer<RefineVertex> > VertexSet;
  typedef hudson::OrderedHashSet<RefineVertex*, hudson::HashPointer<RefineVertex> > VertexUniqueList;

  RefineVertex(const Point& p, unsigned cd = -1): p_(p), id_(-1), cd_(cd), handle_(0) {
  }

  void setContainingDimension(unsigned cd) {
    assert(cd_ == -1);
    assert(int(cd) >= 0);
    cd_ = cd;
  }

  void replaceHandle(Ball *handle) {
    assert(handle->topological() == ambient);
    handle_ = handle;
  }

  Ball *getHandle() const {
    return handle_;
  }

  void addUpperMesh(const Mesh *m) {
    assert(m);
    assert(m->topological() != ambient);
    assert(cd_ <= int(m->topological()));
    std::vector<const Mesh*>& ups = uppers_[m->topological()];

    /* search for the mesh */
    typename std::vector<const Mesh*>::iterator it = std::find(ups.begin(), ups.end(), m);

    if (it != ups.end()) {
      /* found, so we need not add it again */
      return;
    }

    /* Add it and sort.  TODO: be smarter here.  We know inductively that the
     * list is sorted.  We had to search for it, so it should now only cost us
     * constant or linear time to insert it, not n lg n.  */
    dprintf("    %s adding upper %u-mesh %p\n", toString().c_str(), m->topological(), m);
    ups.push_back(m);
    std::sort(ups.begin(), ups.end());

    /* Now add all that mesh's uppers.  TODO: be much smarter here.  We could
     * store the uppers sorted, and then merge, no recursion needed. */
    BOUNDED_FOREACH(const Mesh *upper, m->begin_uppers(), m->end_uppers()) {
      addUpperMesh(upper);
    }

    // Create an empty shell for that level.
    shells_.insert(m);
  }

  void setID(unsigned id) {
    assert(id_ == -1);
    assert(int(id) >= 0);
    dprintf("  vertex %s is now v%u\n", toString().c_str(), id);
    id_ = id;
  }

  typedef typename std::vector<const Mesh*>::const_iterator upper_iterator;
  upper_iterator begin_uppers(unsigned d) const { return uppers_[d].begin(); }
  upper_iterator end_uppers(unsigned d) const { return uppers_[d].end(); }
  const std::vector<const Mesh*>& get_uppers(unsigned d) const { return uppers_[d]; }
  bool hasUpperMesh(const Mesh *m) const { 
    if (m->topological() == ambient) {
      return true;
    } else {
      return shells_.find(m) != shells_.end(); 
    }
  }

  unsigned getID() const { assert(id_ != -1); return id_; }

  unsigned getCD() const { assert(cd_ != -1); return cd_; }

  double dist2(const RefineVertex *other) const {
    return toPoint().dist2(other->toPoint());
  }

  struct IsCloser {
    const RefineVertex *v_;
    IsCloser(const RefineVertex *v): v_(v) { }
    bool operator() (const RefineVertex *a, const RefineVertex *b) const {
      return a->dist2(v_) < b->dist2(v_);
    }
  };

  /***************************************************************************
   * \name Point location.
   *
   * Point location information is linked to the particular mesh.
   ***************************************************************************/

  private:
  ConcentricShells& getShell(const Mesh *m) {
    if (m->topological() == ambient) { return topShell_; }
    else { return shells_.findOrDie(m); }
  }
  const ConcentricShells& getShell(const Mesh *m) const {
    if (m->topological() == ambient) { return topShell_; }
    else { return shells_.findOrDie(m); }
  }

  public:
  bool isCrowded(const Mesh *m) const {
    return ! getShell(m).empty();
  }
  bool isCrowded() const {
    return ! topShell_.empty();
  }

  RefineVertex *getFarVertex(const Mesh *m) const {
    return getShell(m).getFarItem();
  }
  RefineVertex *getFarVertex() const {
    return topShell_.getFarItem();
  }

  void reassignTo(const Mesh *m, RefineVertex *other) {
    getShell(m).reassignTo(toPoint(), other->getShell(m), other->toPoint());
  }

  void addUninserted(const Mesh *m, RefineVertex *uninserted) {
    getShell(m).add(toPoint(), uninserted);
  }

  pair<RefineVertex*, double> findClosest(const Mesh *m, const Point& q, double r2) const {
    return getShell(m).findClosest(toPoint(), q, r2);
  }

  // Requirements of the Vertex signature.

  const Point& toPoint() const { return p_; }

  double x(size_t i) const { return p_[i]; }

  const double *x() const { return p_.data(); }

  std::string toString() const {
    char buffer[4096];
    if (id_ == -1) {
      snprintf(buffer, sizeof(buffer), "v[%u] at %s", cd_, p_.toString().c_str());
    } else {
      snprintf(buffer, sizeof(buffer), "v%u[%u]", getID(), cd_);
    }
    return buffer;
  }

  struct Printer {
    std::string operator()(const RefineVertex *v) const {
      return v->toString();
    }
  };
};



#undef dprintf
#undef dputs

#endif

---