Home Research Papers Posters Manuals Talks Download People Help Internal

libs/ck-libs/pmaf/node.h

Go to the documentation of this file.

#ifndef NODE_H
#define NODE_H

#include <math.h>
#include "ref.h"
#include "charm.h"

class chunk;

class node { 
  double coord[3];       

  int fixed;             

  int surface;           

  int reports;           

  double sumReports[3];  
  nodeRef myRef;         
  chunk *C;              
 public:

  node() {
    reports = 0;
    fixed = surface = -1; 
    for (int i=0; i<3; i++) sumReports[i] = 0.0;
    myRef.reset();
    C = NULL;
  }

  node(double x, double y, double z) { 
    coord[0] = x; coord[1] = y;  coord[2] = z;
    reports = 0;
    fixed = surface = -1; 
    for (int i=0; i<3; i++) sumReports[i] = 0.0;
    myRef.reset();
    C = NULL;
  }

  node(double inNode[3]) { 
    reports = 0;
    fixed = surface = -1; 
    for (int i=0; i<3; i++) {
      coord[i] = inNode[i];
      sumReports[i] = 0.0;
    }
    myRef.reset();
    C = NULL;
  }

  void pup(PUP::er &p) { 
    p|reports; p|fixed; p|surface;
    p(coord,3);
    p(sumReports,3);
  }

  void set(int cid, int idx, chunk *cptr) { myRef.set(cid, idx);  C = cptr; }

  void set(double x, double y, double z) { 
    coord[0] = x; coord[1] = y;  coord[2] = z;
  }

  void set(double inNode[3]) { 
    for (int i=0; i<3; i++) coord[i] = inNode[i];
  }

  void reset() { 
    reports = 0;
    fixed = surface = -1; 
    for (int i=0; i<3; i++) sumReports[i] = 0.0;
    myRef.reset();
    C = NULL;
  }

  int operator==(const node& n) { 
    return ((coord[0] == n.coord[0]) && (coord[1] == n.coord[1]) 
       && (coord[2] == n.coord[2])); }

  node& operator=(const node& n) { 
    fixed = n.fixed;  surface = n.surface;
    for (int i=0; i<3; i++) {
      coord[i] = n.coord[i];
    }
    return *this; 
  }

  double getCoord(int d) { 
    CmiAssert((d<=2) && (d>=0));
    return coord[d]; 
  }
  void fix() { fixed = 1; }
  int isFixed() { return(fixed); }
  void notFixed() { fixed = 0; }
  void setSurface() { surface = 1; }
  int onSurface() { return(surface); }
  void notSurface() { surface = 0; }
  double distance(const node& n) {
    double dx = n.coord[0] - coord[0], dy = n.coord[1] - coord[1], 
      dz = n.coord[2] - coord[2];
    return (sqrt ((dx * dx) + (dy * dy) + (dz * dz)));
  }
  void midpoint(const node& n, node& result) { // get midpoint between this & n
    result.coord[0] = (coord[0] + n.coord[0]) / 2.0;  
    result.coord[1] = (coord[1] + n.coord[1]) / 2.0;
    result.coord[2] = (coord[2] + n.coord[2]) / 2.0;
  }
  node midpoint(const node& n) { 
    double x = (coord[0] + n.coord[0]) / 2.0;
    double y = (coord[1] + n.coord[1]) / 2.0;
    double z = (coord[2] + n.coord[2]) / 2.0;
    return node(x, y, z);
  }

  //  o------------------o------------------o
  // this      L         n         L      result
  void project(const node& n, node& result) { 
    result.coord[0] = n.coord[0] + (n.coord[0] - coord[0]);  
    result.coord[1] = n.coord[1] + (n.coord[1] - coord[1]);
    result.coord[2] = n.coord[2] + (n.coord[2] - coord[2]);
  }

  void shortenLine(const node& n, double l, node& result) {
    double m = distance(n);
    result.coord[0] = (l/m)*(n.coord[0] - coord[0]) + coord[0];
    result.coord[1] = (l/m)*(n.coord[1] - coord[1]) + coord[1];
    result.coord[2] = (l/m)*(n.coord[2] - coord[2]) + coord[2];
  }

  void relocateNode() { // assumes all reports are in
    // calculates a new position from the report data
    if (fixed || (reports==0)) return;
    for (int i=0; i<3; i++) {
      coord[i] = sumReports[i]/reports;
      sumReports[i] = 0.0;
    }
    reports = 0;
  }

  void relocationVote(const node& n) {
    for (int i=0; i<3; i++) sumReports[i] += n.coord[i];
    reports++;
  }
};

#endif

---