Cell.h

Go to the documentation of this file.

#ifndef CELL_H_
#define CELL_H_

#ifdef __cplusplus
#ifdef SWIG
#include "Python.h"
#endif
#include "Material.h"
#include "Region.h"
#include "Surface.h"
#include "Point.h"
#include <limits>
#include <string>
#endif

/* Forward declarations to resolve circular dependencies */
class Universe;
class Surface;
class Region;
class Halfspace;

int cell_id();
void reset_cell_id();
void maximize_cell_id(int cell_id);


enum cellType {

  MATERIAL,

  FILL,

  UNFILLED
};


class Cell {

private:

  static int _n;

  int _uid;

  int _id;

  char* _name;

  cellType _cell_type;

  void* _fill;

  Region* _region;

  Region* _current_region;

  double _volume;

  int _num_instances;

  /* A boolean indicating whether to cell is rotated */
  bool _rotated;

  /* An array with angles in degrees for rotations about x, y, and z */
  double _rotation[3];

  /* A rotation matrix defined in terms of the rotation angles */
  double _rotation_matrix[9];

  /* A boolean indicating whether to cell is translated */
  bool _translated;

  /* An array with translations in x, y and z */
  double _translation[3];

  int _num_rings;

  int _num_sectors;

  Cell* _parent;

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

  void ringify(std::vector<Cell*>& subcells, double max_radius);
  void sectorize(std::vector<Cell*>& subcells);

public:
  Cell(int id=0, const char* name="");
  virtual ~Cell();
  int getUid() const;
  int getId() const;
  char* getName() const;
  cellType getType() const;
  Material* getFillMaterial();
  Universe* getFillUniverse();
  Region* getRegion();
  double getVolume();
  int getNumInstances();
  bool isRotated();
  bool isTranslated();
  double getPhi(std::string units="degrees");
  double getTheta(std::string units="degrees");
  double getPsi(std::string units="degrees");
  double* getRotationMatrix();
  double* getTranslation();
  void retrieveRotation(double* rotations, int num_axes,
                        std::string units="degrees");
  void retrieveTranslation(double* translations, int num_axes);
  int getNumRings();
  int getNumSectors();
  double getMinX();
  double getMaxX();
  double getMinY();
  double getMaxY();
  double getMinZ();
  double getMaxZ();
  boundaryType getMinXBoundaryType();
  boundaryType getMaxXBoundaryType();
  boundaryType getMinYBoundaryType();
  boundaryType getMaxYBoundaryType();
  boundaryType getMinZBoundaryType();
  boundaryType getMaxZBoundaryType();
  int getNumSurfaces() const;
  std::map<int, Halfspace*> getSurfaces() const;
  std::vector<Cell*> getNeighbors() const;
  bool hasParent();
  Cell* getParent();
  Cell* getOldestAncestor();

  int getNumZCylinders();

  std::map<int, Cell*> getAllCells();
  std::map<int, Universe*> getAllUniverses();

  void setName(const char* name);
  void setFill(Material* fill);
  void setFill(Universe* fill);
  void setRegion(Region* region);
  void setVolume(double volume);
  void incrementVolume(double volume);
  void setNumInstances(int num_instances);
  void incrementNumInstances();
  void setRotation(double* rotation, int num_axes, std::string units="degrees");
  void setTranslation(double* translation, int num_axes);
  void setNumRings(int num_rings);
  void setNumSectors(int num_sectors);
  void setParent(Cell* parent);
  void addSurface(int halfspace, Surface* surface);
  void addSurfaceInRegion(int halfspace, Surface* surface);
  void addLogicalNode(int region_type);
  void goUpOneRegionLogical();
  void removeSurface(Surface* surface);
  void addNeighborCell(Cell* cell);

  bool isFissionable();
  bool containsPoint(Point* point);
  bool containsCoords(LocalCoords* coords);
  double minSurfaceDist(Point* point, double azim, double polar);
  double minSurfaceDist(LocalCoords* coords);

  Cell* clone(bool clone_region=true);
  void subdivideCell(double max_radius);
  void buildNeighbors();

  std::string toString();
  void printString();
};


#endif /* CELL_H_ */