Universe.h

Go to the documentation of this file.

#ifndef UNIVERSE_H_
#define UNIVERSE_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>
#endif


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


int universe_id();
void reset_universe_id();
void maximize_universe_id(int universe_id);


enum universeType{

  SIMPLE,

  LATTICE
};


class Universe {

protected:

  static int _n;

  int _uid;

  int _id;

  char* _name;

  universeType _type;

  std::map<int, Cell*> _cells;

  bool _fissionable;

  double _min_x;
  double _max_x;
  double _min_y;
  double _max_y;
  double _min_z;
  double _max_z;

  bool _boundaries_inspected;

  boundaryType _min_x_bound;
  boundaryType _max_x_bound;
  boundaryType _min_y_bound;
  boundaryType _max_y_bound;
  boundaryType _min_z_bound;
  boundaryType _max_z_bound;

public:

  Universe(const int id=-1, const char* name="");
  virtual ~Universe();
  int getUid() const;
  int getId() const;
  char* getName() const;
  universeType getType();
  int getNumCells() const;
  double getMinX();
  double getMaxX();
  double getMinY();
  double getMaxY();
  double getMinZ();
  double getMaxZ();
  boundaryType getMinXBoundaryType();
  boundaryType getMaxXBoundaryType();
  boundaryType getMinYBoundaryType();
  boundaryType getMaxYBoundaryType();
  boundaryType getMinZBoundaryType();
  boundaryType getMaxZBoundaryType();

  Cell* getCell(int cell_id);
  std::map<int, Cell*> getCells() const;
  std::map<int, Cell*> getAllCells();
  std::map<int, Material*> getAllMaterials();
  std::map<int, Universe*> getAllUniverses();
  bool isFissionable();

  void resetBoundaries();
  void calculateBoundaries();
  void setName(const char* name);
  void setType(universeType type);
  void addCell(Cell* cell);
  void removeCell(Cell* cell);

  bool containsPoint(Point* point);
  Cell* findCell(LocalCoords* coords);
  void setFissionability(bool fissionable);
  void subdivideCells(double max_radius=INFINITY);
  void buildNeighbors();

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

  Universe* clone();
};


class Lattice: public Universe {

private:

  int _num_x;

  int _num_y;

  int _num_z;

  bool _non_uniform;

  double _width_x;

  std::vector<double> _widths_x;
  std::vector<double> _accumulate_x;

  double _width_y;

  std::vector<double> _widths_y;
  std::vector<double> _accumulate_y;

  double _width_z;

  std::vector<double> _widths_z;
  std::vector<double> _accumulate_z;

  Point _offset;

  std::vector< std::vector< std::vector< std::pair<int, Universe*> > > >
      _universes;

public:

  Lattice(const int id=-1, const char* name="");
  virtual ~Lattice();

  void setOffset(double x, double y, double z=0.0);
  Point* getOffset();
  int getNumX() const;
  int getNumY() const;
  int getNumZ() const;
  double getWidthX() const;
  double getWidthY() const;
  double getWidthZ() const;
  bool getNonUniform() const;
  const std::vector<double>& getWidthsX() const;
  const std::vector<double>& getWidthsY() const;
  const std::vector<double>& getWidthsZ() const;
  const std::vector<double>& getAccumulateX() const;
  const std::vector<double>& getAccumulateY() const;
  const std::vector<double>& getAccumulateZ() const;
  double getMinX();
  double getMaxX();
  double getMinY();
  double getMaxY();
  double getMinZ();
  double getMaxZ();

  Universe* getUniverse(int lat_x, int lat_y, int lat_z=0) const;
  std::vector< std::vector< std::vector< std::pair<int, Universe*> > > >*
      getUniverses();
  std::map<int, Universe*> getUniqueUniverses();
  std::map<int, double> getUniqueRadius(std::map<int, Universe*> unique_universes);
  std::map<int, Cell*> getAllCells();
  std::map<int, Universe*> getAllUniverses();

  void setNumX(int num_x);
  void setNumY(int num_y);
  void setNumZ(int num_z);
  void setWidth(double width_x, double width_y,
                double width_z=std::numeric_limits<double>::infinity());
  void setNonUniform(bool non_uniform);
  void setWidthsX(std::vector<double> widthsx);
  void setWidthsY(std::vector<double> widthsy);
  void setWidthsZ(std::vector<double> widthsz);
  void setAccumulateX(std::vector<double> accumulatex);
  void setAccumulateY(std::vector<double> accumulatey);
  void setAccumulateZ(std::vector<double> accumulatez);
  void setUniverses(int num_z, int num_y, int num_x, Universe** universes);
  void updateUniverse(int lat_x, int lat_y, int lat_z, Universe* universe);
  void removeUniverse(Universe* universe);
  void subdivideCells(double max_radius=INFINITY);
  void buildNeighbors();

  bool containsPoint(Point* point);
  Cell* findCell(LocalCoords* coords);
  double minSurfaceDist(Point* point, double azim, double polar=M_PI/2.0);

  int getLatX(Point* point);
  int getLatY(Point* point);
  int getLatZ(Point* point);

  int getLatticeCell(Point* point);
  int getLatticeSurface(int cell, Point* point);
  int getLatticeSurfaceOTF(int cell, double z, int surface_2D);

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

  /* Set XYZ widths of non-uniform meshes */
  void setWidths(std::vector<double> widths_x, std::vector<double> widths_y, 
                 std::vector<double> widths_z);
  void computeSizes();

  /* For debug use */
  void printLatticeSizes();

};

template<typename tPair>
struct second_t {
  typename tPair::second_type operator()(const tPair& p) const {
    return p.second;
  }
};


template<typename tMap>
second_t<typename tMap::value_type> pair_second(const tMap& map) {
  return second_t<typename tMap::value_type>();
}

#endif /* UNIVERSE_H_ */