MapStructures.h

Go to the documentation of this file.

#ifndef _MAP_STRUCTURES_H_
#define _MAP_STRUCTURES_H_
#include <iostream>

#include "Vector3D.h"
#include "TaggedVector3D.h"
#include "OrientedBox.h"
using namespace std;

#define XDIM 0
#define YDIM 1
#define ZDIM 2
#define NDIMS 3

#define LEFT_PARTITION 0
#define RIGHT_PARTITION 1
#define INVALID_PARTITION -1

#define NDIMS 3

// Each tpobject has three events, one for 
// each component of its centroid. This helps
// us avoid sorting after each recursive partitioning
// step.

class TPObject;

struct Event {
  int owner;
  float load;
  float position;

  Event(float pos, float ld, int o) : 
    position(pos),
    load(ld),
    owner(o)
  {
  }

  Event() : 
    owner(-1),
    load(0.0),
    position(0.0)
  {
  }

  bool operator<(const Event &e) const {
    return position < e.position;
  }

  bool operator<=(const Event &e) const {
    return position <= e.position;
  }

  bool operator>=(const Event &e) const {
    return position >= e.position;
  }

  void pup(PUP::er &p){
    p|owner;
    p|load;
    p|position;
  }
};

struct OrbObject {
  int partition;
  int lbindex;
  Vector3D<float> centroid;
  int numParticles;

  OrbObject(int tag) : 
    partition(-1),
    lbindex(tag),
    numParticles(0)
   {
   }

  OrbObject() : 
    partition(-1),
    lbindex(-1),
    numParticles(0)
  {
  }

  OrbObject(int tag, int np) : 
    partition(-1),
    lbindex(tag),
    numParticles(np)
  {
  }

  void pup(PUP::er &p){
    p|partition;
    p|lbindex;
    p|centroid;
    p|numParticles;
  }
};

class TPObject{
  public:

  Vector3D<float> centroid;
  float load;
  //int index;
  int lbindex;
  bool migratable;
  //int nparticles;

  int whichPartition;

  bool operator<(const TPObject &t) const{
    return load < t.load;
  }

  TPObject() : 
    load(0.0),
    lbindex(-1),
    whichPartition(-1)
  {
  }

};

class Processor{
  public:

  float load;
  int t;

  bool operator<(const Processor &p) const{
    return load > p.load;
  }
  Processor(){
    load = 0.0;
    t = -1;
  }

  Processor(int pe){
    load = 0.0;
    t = pe;
  }

};

class Node {
  public:
  int x, y, z;
  CkVec<int> procRanks;
#ifdef PRINT_BOUNDING_BOXES
  OrientedBox<float> box;
#endif
};

typedef int (*ComparatorFn) (const void *, const void *);
#endif // _MAP_STRUCTURES_H_