Surface.h

Go to the documentation of this file.

#ifndef SURFACE_H_
#define SURFACE_H_

#ifdef __cplusplus
#ifdef SWIG
#include "Python.h"
#endif
#include "constants.h"
#include "LocalCoords.h"
#include "boundary_type.h"
#include <limits>
#include <map>
#include <vector>
#include <algorithm>
#endif


/* Forward declarations to resolve circular dependencies */
class LocalCoords;
class Cell;


int surface_id();
void reset_surface_id();
void maximize_surface_id(int surface_id);


enum surfaceType {
  PLANE,

  ZCYLINDER,

  XPLANE,

  YPLANE,

  ZPLANE,

  QUADRATIC
};



class Surface {

protected:

  static int _n;

  int _uid;

  int _id;

  char* _name;

  surfaceType _surface_type;

  boundaryType _boundary_type;

  /* Vector of neighboring Cells */
  std::map<int, std::vector<Cell*>* > _neighbors;

public:
  Surface(const int id=0, const char* name="");
  virtual ~Surface();

  int getUid() const;
  int getId() const;
  char* getName() const;
  surfaceType getSurfaceType();
  boundaryType getBoundaryType();


  double getMin(int axis, int halfspace);


  double getMax(int axis, int halfspace);

  virtual double getMinX(int halfspace) = 0;

  virtual double getMaxX(int halfspace) = 0;

  virtual double getMinY(int halfspace) = 0;

  virtual double getMaxY(int halfspace) = 0;

  virtual double getMinZ(int halfspace) = 0;

  virtual double getMaxZ(int halfspace) = 0;

  void setName(const char* name);
  void setBoundaryType(const boundaryType boundary_type);
  void addNeighborCell(int halfspace, Cell* cell);

  virtual double evaluate(const Point* point) const = 0;

  virtual int intersection(Point* point, double azim, double polar,
                           Point* points) = 0;

  bool isPointOnSurface(Point* point);
  bool isCoordOnSurface(LocalCoords* coord);
  double getMinDistance(Point* point, double azim, double polar);
  double getMinDistance(LocalCoords* coord);

  virtual std::string toString() = 0;

  void printString();
};


class Plane: public Surface {

protected:

  double _A;

  double _B;

  double _C;

  double _D;

  friend class Surface;

  friend class ZCylinder;

public:

  Plane(const double A, const double B, const double C, const double D,
        const int id=0, const char* name="");

  double getMinX(int halfspace);
  double getMaxX(int halfspace);
  double getMinY(int halfspace);
  double getMaxY(int halfspace);
  double getMinZ(int halfspace);
  double getMaxZ(int halfspace);
  double getA();
  double getB();
  double getC();
  double getD();

  double evaluate(const Point* point) const;
  int intersection(Point* point, double azim, double polar, Point* points);

  std::string toString();
};


class XPlane: public Plane {

private:

  double _x;

public:
  XPlane(const double x, const int id=0, const char* name="");

  void setX(const double x);

  double getX();
  double getMinX(int halfspace);
  double getMaxX(int halfspace);

  std::string toString();
};


class YPlane: public Plane {

private:

  double _y;

public:
  YPlane(const double y, const int id=0, const char* name="");

  void setY(const double y);

  double getY();
  double getMinY(int halfspace);
  double getMaxY(int halfspace);

  std::string toString();
};


class ZPlane: public Plane {

private:

  double _z;

public:
  ZPlane(const double z, const int id=0, const char* name="");

  void setZ(const double z);

  double getZ();
  double getMinZ(int halfspace);
  double getMaxZ(int halfspace);

  std::string toString();
};


class ZCylinder: public Surface {

private:

  Point _center;

  double _radius;

  double _A;

  double _B;

  double _C;

  double _D;

  double _E;

  friend class Surface;

  friend class Plane;

public:
  ZCylinder(const double x, const double y, const double radius,
            const int id=0, const char* name="");

  double getX0();
  double getY0();
  double getRadius();
  double getMinX(int halfspace);
  double getMaxX(int halfspace);
  double getMinY(int halfspace);
  double getMaxY(int halfspace);
  double getMinZ(int halfspace);
  double getMaxZ(int halfspace);

  double evaluate(const Point* point) const;
  int intersection(Point* point, double azim, double polar, Point* points);

  std::string toString();
};


inline double Surface::getMinDistance(Point* point, double azim, double polar) {

  /* Point array for intersections with this Surface */
  Point intersections[2];

  /* Find the intersection Point(s) */
  int num_inters = intersection(point, azim, polar, intersections);
  double distance = INFINITY;

  /* If there is one intersection Point */
  if (num_inters == 1)
    distance = intersections[0].distanceToPoint(point);

  /* If there are two intersection Points */
  else if (num_inters == 2) {
    double dist1 = intersections[0].distanceToPoint(point);
    double dist2 = intersections[1].distanceToPoint(point);

    /* Determine which intersection Point is nearest */
    if (dist1 < dist2)
      distance = dist1;
    else
      distance = dist2;
  }

  return distance;
}


inline double Plane::evaluate(const Point* point) const {
  double x = point->getX();
  double y = point->getY();
  double z = point->getZ();

  return (_A * x + _B * y + _C * z + _D);
}


inline double ZCylinder::getRadius() {
  return this->_radius;
}


inline double ZCylinder::evaluate(const Point* point) const {
  double x = point->getX();
  double y = point->getY();
  return (_A * x * x + _B * y * y + _C * x + _D * y + _E);
}


#endif /* SURFACE_H_ */