---

ArbitraryCartesianGrid3D.h

/****************************************************************************
 *                                                                          *
 *  Program: FDDlib                                                         *
 *  Version: 1.1                                                            *
 *                                                                          *
 *  Copyright (C) 2002 - 2004 by Eric Miller and Dana Brooks                *
 *  All rights reserved.                                                    *
 *                                                                          *
 *  This software is Version 1.1 of the fddlib tomography toolbox.          *
 *  It is not to be redistributed or used for any commercial purpose        *
 *  without the prior written consent of the authors and Northeastern       *
 *  University.                                                             *
 *                                                                          *
 *  This software is provided as is, and any express or implied warranties, *
 *  including but not limited to the implied warranty of merchantability    *
 *  and the implied warranty of fitness for a particular purpose, are dis-  *
 *  claimed.  In no event shall the authors or Northeastern University be   *
 *  liable for any direct, indirect, incidental, special, exemplary, or     *
 *  consequential damages (including but not limited to procurement of      * 
 *  substitute goods or services; loss of use, data, or profits; or busi-   *
 *  ness interruption) however caused and on any theory of liability,       *
 *  whether in contract, strict liability, or tort (including negligence or *
 *  otherwise) arising in any way from the use of this software, even if    *
 *  advised of the possibility of such damage.                              *
 *                                                                          *
 *  Portions of this code benefit from ideas from Kyle Guilbert, Greg       *
 *  Boverman, Derek Uluski, David Kaeli, and Jennifer Black                 *
 *                                                                          *
 ****************************************************************************/

#ifndef _ARBCART_GRID3D_H_
#define _ARBCART_GRID3D_H_

#include <vector>
#include <string>
#include <list>
#include "CartesianNode3D.h"
#include "grid_enums.h"
#include "Anomaly3D.h"

namespace FDDlib {

class ArbitraryCartesianGrid3D {
public:
  
  static const int DEFAULT_SPACING = 1;

protected:
  
  int numx_;

  int numy_;

  int numz_;
  
  struct s_offsets {
    int xoffset;

    int yoffset;

    int zoffset;
  };

  std::vector<CartesianNode3D> nodeList_;
  
  double energySpeed_;
  
  int numActiveNodes_;
  
  std::vector<double> deltax;

  std::vector<double> deltay;

  std::vector<double> deltaz;

  void setupNodes() throw(std::string);
  
  static const int UNKNOWN_NUMACTIVE = -1;
  
public:

  ArbitraryCartesianGrid3D(int numx, int numy, int numz, 
                  double energySpeed) throw(std::string);
  
  ArbitraryCartesianGrid3D(int numx, int numy, int numz, 
                  double energySpeed, 
                  const std::vector<double> &dx,
                  const std::vector<double> &dy,
                  const std::vector<double> &dz) throw(std::string);

  virtual ~ArbitraryCartesianGrid3D();
  
  void setDelta(const std::vector<double> &dx, 
                const std::vector<double> &dy, 
                const std::vector<double> &dz) throw(std::string);
  
  std::vector<double> getDxList() const;

  std::vector<double> getDyList() const;

  std::vector<double> getDzList() const;

  virtual double averageDx() const;
  
  virtual double averageDy() const;
  
  virtual double averageDz() const;
  
  int numX() const;
  
  int numY() const;
  
  int numZ() const;
  
  virtual void computeNormals(int maxneighbors, int order, double tol)
    throw(std::string);
  
  virtual void analyticalNormals() throw(std::string);
  
  std::list<CartesianNode3D*> getBorderBySide(gridSide3D side) const;

  std::list<CartesianNode3D*> getAllBorders() const;
  
  int offsetsToIndex(int xoffset, int yoffset, int zoffset) const throw(std::string);

  CartesianNode3D* getNode(int ind) const throw(std::string);

  int numNodes() const;

  void fillUniformProperty(Property* prop) throw(std::string);

  void insertAnomaly(const Anomaly3D& anom);

  void setEnergySpeed(double energySpeed);

  double getEnergySpeed() const;

  int numActiveNodes() const throw(std::string);

  void generateLinearIndices();
  
  void createLayeredBackground(const std::vector<Property*> &proplist,
       const std::vector<int> &zdepthlist) throw(std::string);

  int numBorderNodes() const;

};

} // end namespace

#endif

---