Initial creation of meshtools reader for FEM4EllipticPDE. Corrected the initial name and email.

examples/utReadRectilinearMesh.cpp

@@ -0,0 +1,7 @@
+#include "LemmaObject.h"
+
+int main(int argc, char**argv) {
+
+    std::cout << "Hello World!" << std::endl;
+
+}

include/exceptions.h

@@ -0,0 +1,47 @@
+// ===========================================================================
+// 
+//       Filename:  exceptions.h
+// 
+//    Description:  Exception classes
+// 
+//        Version:  0.0
+//        Created:  03/19/2013 12:22:19 PM
+//       Revision:  none
+//       Compiler:  Tested with g++ 
+// 
+//         Author:  M. Andy Kass (MAK)
+//
+//   Organisation:  US Geological Survey
+//                  
+//
+//          Email:  mkass@usgs.gov
+// 
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#ifndef __exceptions_h
+#define __exceptions_h
+
+#include "formalhaut.h"
+
+namespace formalhaut {
+
+/// Generic file I/O error
+class GenericFileIOError : public std::runtime_error {
+	public: GenericFileIOError(const std::string &filename);
+};
+
+} //end of namespace formalhaut
+#endif

include/grid.h

@@ -0,0 +1,87 @@
+// ===========================================================================
+//
+//       Filename:  grid.h
+//
+//    Description:
+//
+//        Version:  0.0
+//        Created:  10/25/2009 07:38:32 AM
+//       Revision:  none
+//       Compiler:  g++ (c++)
+//
+//         Author:  Trevor Irons (ti)
+//         			M. Andy Kass (MAK)
+//
+//   Organisation:  Colorado School of Mines (CSM)
+//                  United States Geological Survey (USGS)
+//
+//          Email:  tirons@mines.edu, tirons@usgs.gov
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#ifndef __GRID_H
+#define __GRID_H
+#include "formalhaut.h"
+
+namespace formalhaut {
+
+// ===============================================================================
+//        Class:  Grid
+/// \brief Abstract base class for grids.
+/// \details Grids define values in space, they may either be an integral part
+/// of models, or simply the output of a forward modelling procedure.
+// ===============================================================================
+
+class Grid {
+
+    friend std::ostream &operator<<(std::ostream &stream,
+            const Grid &ob);
+
+    public:
+
+    // ====================  LIFECYCLE     ===================================
+
+    // ====================  OPERATORS     ===================================
+
+    // ====================  OPERATIONS    ===================================
+
+    // ====================  ACCESS        ===================================
+
+    // ====================  INQUIRY       ===================================
+
+	gridtype GetGridType();
+
+    protected:
+
+    // ====================  LIFECYCLE     ===================================
+
+    /// Default protected constructor.
+    Grid ();
+
+    /// Default protected constructor.
+    ~Grid ();
+
+    // ====================  DATA MEMBERS  ===================================
+
+	gridtype TypeOfGrid;
+
+    private:
+
+}; // -----  end of class  Grid  -----
+
+
+} // namespace formalhaut
+#endif

include/logging.h

@@ -0,0 +1,117 @@
+// ===========================================================================
+// 
+//       Filename:  logging.h
+// 
+//    Description:  Simple logging class.
+// 
+//        Version:  0.0
+//        Created:  09/12/2013 03:23:30 PM
+//       Revision:  none
+//       Compiler:  Tested with g++ 
+// 
+//         Author:  M. Andy Kass (MAK)
+//
+//   Organisation:  US Geological Survey
+//                  
+//
+//          Email:  mkass@usgs.gov
+// 
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#ifndef __logging_h
+#define __logging_h
+
+#include "formalhaut.h"
+#include "exceptions.h"
+#include <time.h>
+
+namespace formalhaut {
+
+
+// ===================================================================
+//        Class:  Logging
+/// \brief  
+/// \details 
+// ===================================================================
+class Logging {
+
+	friend std::ostream &operator<<(std::ostream &stream,
+		const Logging &ob);
+
+public:
+
+	// ====================  LIFECYCLE     =======================
+
+	static Logging* New();                    
+
+	void Delete();
+
+	// ====================  OPERATORS     =======================
+
+	// ====================  OPERATIONS    =======================
+
+	/// Close the log file
+	void CloseLogFile();
+
+	/// Write a single line to the log file
+	void WriteLogLine(const std::string line);
+
+	/// Write header information in the logger
+	void WriteHeader(const std::string& name,const std::string& ver);
+
+	/// Get current date and time, formatted
+	std::string GetDateTime();
+
+	/// Write successful completion
+	void WriteCloser();
+
+	/// Write a long dashed line
+	void WriteDashedLine();
+
+	// ====================  ACCESS        =======================
+
+	/// Set and open the log file
+	void SetLogFile(const std::string& fname);
+
+	// ====================  INQUIRY       =======================
+
+	std::string GetLogFile();
+
+
+protected:
+
+	// ====================  LIFECYCLE     =======================
+
+	/// Default protected constructor. 
+	Logging ();                    
+
+	/// Default protected constructor. 
+	~Logging ();                    
+
+	// ====================  DATA MEMBERS  =========================
+
+	// Log file name
+	std::string LogFile;
+
+	// File object
+	std::ofstream outfile;
+
+private:
+
+}; // -----  end of class  Logging  -----
+
+} // end of namespace
+#endif

include/rectilinearstructuredgrid.h

@@ -0,0 +1,110 @@
+// ===========================================================================
+// 
+//       Filename:  rectilinearstructuredgrid.h
+// 
+//    Description:  
+// 
+//        Version:  0.0
+//        Created:  09/16/2013 01:49:40 PM
+//       Revision:  none
+//       Compiler:  Tested with g++ 
+// 
+//         Author:  M. Andy Kass (MAK)
+//
+//   Organisation:  US Geological Survey
+//                  
+//
+//          Email:  mkass@usgs.gov
+// 
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#ifndef __RECTILINEARSTRUCTUREDGRID_H
+#define __RECTILINEARSTRUCTUREDGRID_H
+#include "formalhaut.h"
+#include "structuredgrid.h"
+#include "exceptions.h"
+
+namespace formalhaut {
+
+
+// ===================================================================
+//        Class:  RectilinearStructuredGrid
+/// \brief  
+/// \details 
+// ===================================================================
+class RectilinearStructuredGrid : public StructuredGrid {
+	friend std::ostream &operator<<(std::ostream &stream,
+		const RectilinearStructuredGrid &ob);
+
+public:
+
+	// ====================  LIFECYCLE     =======================
+
+	static RectilinearStructuredGrid* New();                    
+
+	void Delete();
+
+	// ====================  OPERATORS     =======================
+
+	// ====================  OPERATIONS    =======================
+	
+	/// Compute the centroid of each vectorized cell
+	void ComputeCentroids();
+
+	/// Set the dimensions of the cells
+	void SetCellDims(const std::vector<VectorXr>& dx3v);
+
+	// ====================  ACCESS        =======================
+	
+	/// Return actors containing the mesh (7 actors returned.  1st is 
+	/// bounding box and the next 6 are prism faces)
+	std::vector<vtkActor*> ReturnMeshActor();
+
+	// ====================  INQUIRY       =======================
+	
+	/// Return dx,dy,dz
+	std::vector<VectorXr> GetCellDims();
+
+	/// Return a particular set of corners
+	VectorXr GetCorners(const int& vecpos);
+
+	/// Display the grid
+	void DisplayMesh();
+
+
+
+protected:
+
+	// ====================  LIFECYCLE     =======================
+
+	/// Default protected constructor. 
+	RectilinearStructuredGrid ();                    
+
+	/// Default protected constructor. 
+	~RectilinearStructuredGrid ();  
+
+	/// Vectorized cell widths.  Not the most memory efficient, but 
+	/// efficient computationally (by that I mean I'm lazy and tired
+	/// and this seems like the easiest way).
+	Vector3Xr CW;	
+
+	// ====================  DATA MEMBERS  =========================
+
+private:
+
+}; // -----  end of class  RectilinearStructuredGrid  -----
+} // end of namespace formalhaut
+#endif

include/structuredgrid.h

@@ -0,0 +1,144 @@
+// ===========================================================================
+// 
+//       Filename:  structuredgrid.h
+// 
+//    Description:  Derived class for structured grids.  Base class to 
+//    				regular and rectilinear grids.
+// 
+//        Version:  0.0
+//        Created:  09/12/2013 08:29:26 AM
+//       Revision:  none
+//       Compiler:  Tested with g++ 
+// 
+//         Author:  M. Andy Kass (MAK)
+//
+//   Organisation:  US Geological Survey
+//                  
+//
+//          Email:  mkass@usgs.gov
+// 
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#ifndef __STRUCTUREDGRID_H
+#define __STRUCTUREDGRID_H
+#include "formalhaut.h"
+#include "grid.h"
+#include "exceptions.h"
+#include "logging.h"
+
+namespace formalhaut {
+
+// ===================================================================
+//        Class:  StructuredGrid
+/// \brief  
+/// \details 
+// ===================================================================
+class StructuredGrid : public Grid {
+	friend std::ostream &operator<<(std::ostream &stream,
+		const StructuredGrid &ob);
+
+public:
+
+	// ====================  LIFECYCLE     =======================
+
+	static StructuredGrid* New();                    
+
+	void Delete();
+
+	// ====================  OPERATORS     =======================
+
+	// ====================  OPERATIONS    =======================
+
+	/// Set the number of cells in each direction
+	void SetNCells(const Eigen::Matrix<int,3,1>& ncells);
+
+	/// Set origin (top south west)
+	void SetOrigin(const Vector3r& origin);
+
+
+	// ====================  ACCESS        =======================
+
+	/// Read mesh parameters from Meshtools format
+	void ReadMeshtoolsGrid(const std::string& fname);
+
+	/// Attach a log object for writing lines to log file
+	void AttachLogObject(Logging* logobj);
+
+	// ====================  INQUIRY       =======================
+
+	/// Given a cell count in each direction, return the position that
+	/// cell has in the unwrapped vector.  Indexed from zero.
+	int GetVectorPosition(const Eigen::Matrix<int,3,1>& cellpos);
+
+	/// Given a position in space, determine if the position exists
+	/// within the model region and then if so, in what cell does that 
+	/// position exist.
+	int QueryCellPosition(const Vector3r& cellpos);
+
+	/// Return vector with the number of cells in each direction
+	Eigen::Matrix<int,3,1> GetNCells();
+
+	/// Return a vector of the origin
+	Vector3r GetOrigin();
+
+	/// Return the centroid matrix
+	Vector3Xr GetCentroids();
+
+	/// Return a particular centroid
+	Vector3r GetCentroid(const int& vecpos);
+
+
+
+
+protected:
+
+	// ====================  LIFECYCLE     =======================
+
+	/// Default protected constructor. 
+	StructuredGrid ();                    
+
+	/// Default protected constructor. 
+	~StructuredGrid ();                    
+
+	// ====================  DATA MEMBERS  =========================
+
+	/// Number of cells in x,y,z
+	Eigen::Matrix<int,3,1> Nx3;
+
+	/// Cell spacings in each dimension (3 x n)
+	Vector3Xr Dx3;
+
+	/// Origin (3 x 1)
+	Vector3r Origin;
+
+	/// Vectorized edge coordinates
+	MatrixXr VecEdgCoord;
+
+	/// Vectorized centroid coordinates (3 x n)
+	Vector3Xr VecCentroid;
+
+	/// Log object
+	Logging* LogObj;
+
+	/// Vector of cell spacings in each dimension (3 x n)
+	std::vector<VectorXr> Dx3v;
+
+private:
+
+
+}; // -----  end of class  StructuredGrid  -----
+} // end of namespace formalhaut
+#endif

src/exceptions.cpp

@@ -0,0 +1,47 @@
+// ===========================================================================
+// 
+//       Filename:  exceptions.cpp
+// 
+//    Description:  Holds the exceptions for the project
+// 
+//        Version:  0.0
+//        Created:  03/19/2013 12:18:41 PM
+//       Revision:  none
+//       Compiler:  Tested with g++ 
+// 
+//         Author:  M. Andy Kass (MAK)
+//
+//   Organisation:  US Geological Survey
+//                  
+//
+//          Email:  mkass@usgs.gov
+// 
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include "exceptions.h"
+
+namespace formalhaut {
+
+	GenericFileIOError::GenericFileIOError(const std::string &filename) :
+			runtime_error("FILE I/O ERROR"){
+				std::cout << std::endl;
+				std::cout << "File I/O error while accessing " << 
+					filename << "." << std::endl;
+				std::cout << "Terminating." << std::endl;
+			}
+
+} // End of namespace formalhaut
+

src/grid.cpp

@@ -0,0 +1,55 @@
+// ===========================================================================
+// 
+//       Filename:  grid.cpp
+// 
+//    Description:  
+// 
+//        Version:  0.0
+//        Created:  10/25/2009 07:42:08 AM
+//       Revision:  none
+//       Compiler:  g++ (c++)
+// 
+//         Author:  M. Andy Kass (MAK)
+//                  Trevor Irons (ti)
+//
+//   Organisation:  United States Geological Survey (USGS)
+//
+//          Email:  mkass@usgs.gov
+// 
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include "grid.h"
+
+namespace formalhaut {
+
+	std::ostream &operator<<(std::ostream &stream, 
+				const Grid &ob) {
+		stream << "Class: Grid\n";
+		//stream << *(ReferenceCountedObject*)(&ob);
+		return stream;
+	}
+
+	Grid::Grid  ( ) {
+	}
+	
+	Grid::~Grid  ( ) {
+	}
+
+	gridtype Grid::GetGridType() {
+		return this->TypeOfGrid;
+	}
+
+}

src/logging.cpp

@@ -0,0 +1,128 @@
+// ===========================================================================
+// 
+//       Filename:  logging.cpp
+// 
+//    Description:  
+// 
+//        Version:  0.0
+//        Created:  09/12/2013 03:26:27 PM
+//       Revision:  none
+//       Compiler:  Tested with g++ 
+// 
+//         Author:  M. Andy Kass (MAK)
+//
+//   Organisation:  US Geological Survey
+//                  
+//
+//          Email:  mkass@usgs.gov
+// 
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include "logging.h"
+
+namespace formalhaut {
+
+	std::ostream &operator<<(std::ostream &stream,
+		const Logging &ob) {
+		stream << "Class: Logging\n";
+		stream << "Output file: " << ob.LogFile << "\n";
+		stream << "\n";
+
+
+		return stream;
+	}
+
+	Logging* Logging::New() {
+		return new Logging;
+	}
+
+	void Logging::Delete() {
+		if (this->outfile.is_open()) {
+			this->outfile.close();
+		}
+		delete this;
+	}
+
+	Logging::Logging() {
+
+	}
+
+	Logging::~Logging() {
+
+	}
+
+	void Logging::CloseLogFile() {
+
+
+		if (this->outfile.is_open()) {
+			this->outfile.close();
+		}
+
+	}
+
+	void Logging::WriteLogLine(const std::string line) {
+		
+		this->outfile << line << std::endl;
+
+	}
+
+	void Logging::WriteHeader(const std::string& name, const 
+		std::string& ver) {
+		
+		this->outfile << name << std::endl;
+		this->outfile << "version " << ver << std::endl << std::endl;
+
+		this->outfile << "Run began at " << this->GetDateTime() 
+			<< std::endl << std::endl;
+	}
+
+	std::string Logging::GetDateTime() {
+		time_t now = time(0);
+		struct tm tstruct;
+		char buf[80];
+		tstruct = *localtime(&now);
+		strftime(buf,sizeof(buf),"%Y-%m-%d.%X",&tstruct);
+		return buf;
+	
+	}
+
+	void Logging::WriteCloser() {
+
+		this->outfile << "Successfully ended at " << this->GetDateTime()
+			<< std::endl;
+		this->outfile.close();
+	}
+
+	void Logging::WriteDashedLine() {
+		std::string dashes;
+		dashes = "------------------------------------";
+		dashes = dashes + dashes;
+		this->outfile << dashes << std::endl;
+	}
+
+	void Logging::SetLogFile(const std::string& fname) {
+
+		this->LogFile = fname;
+		this->outfile.open(this->LogFile.c_str());
+	}
+
+	std::string Logging::GetLogFile() {
+		return this->LogFile;
+	}
+
+
+
+} // end of namespace formalhaut

src/rectilinearstructuredgrid.cpp

@@ -0,0 +1,433 @@
+// ===========================================================================
+// 
+//       Filename:  rectilinearstructuredgrid.cpp
+// 
+//    Description:  
+// 
+//        Version:  0.0
+//        Created:  09/16/2013 01:55:17 PM
+//       Revision:  none
+//       Compiler:  Tested with g++ 
+// 
+//         Author:  M. Andy Kass (MAK)
+//
+//   Organisation:  US Geological Survey
+//                  
+//
+//          Email:  mkass@usgs.gov
+// 
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include "rectilinearstructuredgrid.h"
+
+namespace formalhaut {
+
+	std::ostream &operator<<(std::ostream &stream,
+		const RectilinearStructuredGrid &ob) {
+
+		return stream;
+	}
+
+	RectilinearStructuredGrid::RectilinearStructuredGrid() {
+		this->TypeOfGrid = rectilinear;
+	}
+
+	RectilinearStructuredGrid::~RectilinearStructuredGrid() {
+
+	}
+
+	RectilinearStructuredGrid* RectilinearStructuredGrid::New() {
+		return new RectilinearStructuredGrid;
+	}
+
+	void RectilinearStructuredGrid::Delete() {
+		delete this;
+	}
+
+	void RectilinearStructuredGrid::ComputeCentroids() {
+
+		int ntot;
+		ntot = this->Nx3(0)*this->Nx3(1)*this->Nx3(2);
+		this->VecCentroid.resize(Eigen::NoChange,ntot);
+		this->CW.resize(Eigen::NoChange,ntot);
+		int mm = 0;
+
+		// First z changes, then x then y
+		// first depth, then easting, then northing
+		//Original
+		
+		///*
+		//std::cout << this->Dx3v[0].segment(0,1).sum() << std::endl;
+		//std::cout << this->Dx3v[0](0) << "  " << this->Dx3v[0](1) <<
+		//	std::endl;
+		//std::cout << this->Dx3v[0].segment(0,1).sum() - 
+		//	this->Dx3v[0](1)/2 + this->Dx3v[0](0) + 
+		//	this->Origin(0) << std::endl;
+		for (int jj=0;jj<this->Nx3(1);jj++) {
+			for (int ii=this->Nx3(0)-1;ii>-1;ii--) {
+			//for (int ii=0;ii<this->Nx3(0);ii++) {
+				for (int kk=0;kk<this->Nx3(2);kk++) {
+		
+		//*/
+		/*
+		for (int ii=0;ii<this->Nx3(0);ii++) {
+			for (int jj=0;jj<this->Nx3(1);jj++) {
+				for (int kk=0;kk<this->Nx3(2);kk++) {
+		*/
+					this->VecCentroid(0,mm) = this->Origin(0) +
+						this->Dx3v[0].segment(0,ii).sum() - 
+						this->Dx3v[0](ii)/2 + this->Dx3v[0](ii);
+					this->VecCentroid(1,mm) = this->Origin(1) +
+						this->Dx3v[1].segment(0,jj).sum() -
+						this->Dx3v[1](jj)/2 + this->Dx3v[1](jj);
+					this->VecCentroid(2,mm) = this->Origin(2) +
+						this->Dx3v[2].segment(0,kk).sum() -
+						this->Dx3v[2](kk)/2 + this->Dx3v[2](kk);
+					this->CW(0,mm) = this->Dx3v[0](ii);
+					this->CW(1,mm) = this->Dx3v[1](jj);
+					this->CW(2,mm) = this->Dx3v[2](kk);
+					mm++;
+				}
+			}
+		}
+
+	}
+
+	void RectilinearStructuredGrid::SetCellDims(const
+		std::vector<VectorXr>& dx3v) {
+
+		this->Dx3v[0] = dx3v[0];
+		this->Dx3v[1] = dx3v[1];
+		this->Dx3v[2] = dx3v[2];
+
+	}
+
+	std::vector<vtkActor*> RectilinearStructuredGrid::ReturnMeshActor() {
+
+		// Coords are edges of cells, not centroids
+		vtkFloatArray *xCoords = vtkFloatArray::New();
+		vtkFloatArray *yCoords = vtkFloatArray::New();
+		vtkFloatArray *zCoords = vtkFloatArray::New();
+		Real val;
+
+		val = this->Origin(0);
+		xCoords->InsertNextValue(val);
+		for (int ii=1;ii<=this->Nx3(0)+1;ii++) {
+			val = this->Origin(0) + this->Dx3v[0].segment(0,ii-1).sum();
+			xCoords->InsertNextValue(val);
+		}
+		val = this->Origin(1);
+		yCoords->InsertNextValue(val);
+		for (int ii=1;ii<=this->Nx3(1)+1;ii++) {
+			val = this->Origin(1) + this->Dx3v[1].segment(0,ii-1).sum();
+			yCoords->InsertNextValue(val);
+		}
+		val = -1 * this->Origin(2);
+		zCoords->InsertNextValue(val);
+		for (int ii=1;ii<=this->Nx3(2)+1;ii++) {
+			val = this->Origin(2) + this->Dx3v[2].segment(0,ii-1).sum();
+			val = -1*val;
+			zCoords->InsertNextValue(val);
+		}
+
+		vtkRectilinearGrid *rgrid = vtkRectilinearGrid::New();
+		rgrid->SetDimensions(this->Nx3(1)+2,this->Nx3(0)+2,this->Nx3(2)+2);
+		rgrid->SetXCoordinates(yCoords);
+		rgrid->SetYCoordinates(xCoords);
+		rgrid->SetZCoordinates(zCoords);
+
+		vtkRectilinearGridGeometryFilter *plane = 
+			vtkRectilinearGridGeometryFilter::New();
+		plane->SetInputData(rgrid);
+		//plane->SetExtent(0,this->Nx3(0),0,this->Nx3(1),0,this->Nx3(2));
+		//Just for testing
+		plane->SetExtent(0,0,0,this->Nx3(0)+1,0,this->Nx3(2)+1);
+
+		vtkPolyDataMapper *rgridmapper = vtkPolyDataMapper::New();
+		rgridmapper->SetInputConnection(plane->GetOutputPort());
+
+		vtkActor *wireActor = vtkActor::New();
+		wireActor->SetMapper(rgridmapper);
+		wireActor->GetProperty()->SetRepresentationToWireframe();
+		wireActor->GetProperty()->SetColor(0,1,0);
+
+		//Make an actor for each face
+		//Second face
+		vtkRectilinearGridGeometryFilter *plane1 =
+			vtkRectilinearGridGeometryFilter::New();
+		plane1->SetInputData(rgrid);
+		plane1->SetExtent(this->Nx3(1)+1,this->Nx3(1)+1,0,this->Nx3(0)+1,
+			0,this->Nx3(2)+1);
+		vtkPolyDataMapper *rgridmapper1 = vtkPolyDataMapper::New();
+		rgridmapper1->SetInputConnection(plane1->GetOutputPort());
+		vtkActor *wireActor1 = vtkActor::New();
+		wireActor1->SetMapper(rgridmapper1);
+		wireActor1->GetProperty()->SetRepresentationToWireframe();
+		wireActor1->GetProperty()->SetColor(0,1,0);
+		//Third face
+		vtkRectilinearGridGeometryFilter *plane2 =
+			vtkRectilinearGridGeometryFilter::New();
+		plane2->SetInputData(rgrid);
+		plane2->SetExtent(0,this->Nx3(1)+1,0,0,
+			0,this->Nx3(2)+1);
+		vtkPolyDataMapper *rgridmapper2 = vtkPolyDataMapper::New();
+		rgridmapper2->SetInputConnection(plane2->GetOutputPort());
+		vtkActor *wireActor2 = vtkActor::New();
+		wireActor2->SetMapper(rgridmapper2);
+		wireActor2->GetProperty()->SetRepresentationToWireframe();
+		wireActor2->GetProperty()->SetColor(0,1,0);
+		//Fourth face
+		vtkRectilinearGridGeometryFilter *plane3 =
+			vtkRectilinearGridGeometryFilter::New();
+		plane3->SetInputData(rgrid);
+		plane3->SetExtent(0,this->Nx3(1)+1,this->Nx3(0)+1,this->Nx3(0)+1,
+			0,this->Nx3(2)+1);
+		vtkPolyDataMapper *rgridmapper3 = vtkPolyDataMapper::New();
+		rgridmapper3->SetInputConnection(plane3->GetOutputPort());
+		vtkActor *wireActor3 = vtkActor::New();
+		wireActor3->SetMapper(rgridmapper3);
+		wireActor3->GetProperty()->SetRepresentationToWireframe();
+		wireActor3->GetProperty()->SetColor(0,1,0);
+		//Fifth face
+		vtkRectilinearGridGeometryFilter *plane4 =
+			vtkRectilinearGridGeometryFilter::New();
+		plane4->SetInputData(rgrid);
+		plane4->SetExtent(0,this->Nx3(1)+1,0,this->Nx3(0)+1,
+			0,0);
+		vtkPolyDataMapper *rgridmapper4 = vtkPolyDataMapper::New();
+		rgridmapper4->SetInputConnection(plane4->GetOutputPort());
+		vtkActor *wireActor4 = vtkActor::New();
+		wireActor4->SetMapper(rgridmapper4);
+		wireActor4->GetProperty()->SetRepresentationToWireframe();
+		wireActor4->GetProperty()->SetColor(0,1,0);
+		//Sixth face
+		vtkRectilinearGridGeometryFilter *plane5 =
+			vtkRectilinearGridGeometryFilter::New();
+		plane5->SetInputData(rgrid);
+		plane5->SetExtent(0,this->Nx3(1)+1,0,this->Nx3(0)+1,
+			this->Nx3(2)+1,this->Nx3(2)+1);
+		vtkPolyDataMapper *rgridmapper5 = vtkPolyDataMapper::New();
+		rgridmapper5->SetInputConnection(plane5->GetOutputPort());
+		vtkActor *wireActor5 = vtkActor::New();
+		wireActor5->SetMapper(rgridmapper5);
+		wireActor5->GetProperty()->SetRepresentationToWireframe();
+		wireActor5->GetProperty()->SetColor(0,1,0);
+		
+		vtkSmartPointer<vtkOutlineFilter> outlineFilter = 
+			vtkSmartPointer<vtkOutlineFilter>::New();
+		outlineFilter->SetInputData(rgrid);
+		vtkSmartPointer<vtkDataSetMapper> outlinemapper = 
+			vtkSmartPointer<vtkDataSetMapper>::New();
+		outlinemapper->SetInputConnection(outlineFilter->GetOutputPort());
+
+		vtkActor *outlineActor = vtkActor::New();
+		outlineActor->SetMapper(outlinemapper);
+
+		std::vector<vtkActor*> actorreturn;
+		// Order of actors:
+		// 1. outlineActor
+		// 2-7. plane 0-5
+		
+		actorreturn.push_back(outlineActor);
+		actorreturn.push_back(wireActor);
+		actorreturn.push_back(wireActor1);
+		actorreturn.push_back(wireActor2);
+		actorreturn.push_back(wireActor3);
+		actorreturn.push_back(wireActor4);
+		actorreturn.push_back(wireActor5);
+
+		return actorreturn;
+
+
+	}
+
+	std::vector<VectorXr> RectilinearStructuredGrid::GetCellDims() {
+		return this->Dx3v;
+	}
+
+	VectorXr RectilinearStructuredGrid::GetCorners(const int& vecpos) {
+		VectorXr corners;
+		corners.resize(6);
+		Vector3r cntr;
+
+		cntr = this->VecCentroid.col(vecpos);
+
+		corners(0) = cntr(0) - this->CW(0,vecpos)/2;
+		corners(1) = cntr(0) + this->CW(0,vecpos)/2;
+		corners(2) = cntr(1) - this->CW(1,vecpos)/2;
+		corners(3) = cntr(1) + this->CW(1,vecpos)/2;
+		corners(4) = cntr(2) - this->CW(2,vecpos)/2;
+		corners(5) = cntr(2) + this->CW(2,vecpos)/2;
+		
+		return corners;
+	}
+
+	void RectilinearStructuredGrid::DisplayMesh() {
+
+		// Coords are edges of cells, not centroids
+		vtkFloatArray *xCoords = vtkFloatArray::New();
+		vtkFloatArray *yCoords = vtkFloatArray::New();
+		vtkFloatArray *zCoords = vtkFloatArray::New();
+		Real val;
+
+		val = this->Origin(0);
+		xCoords->InsertNextValue(val);
+		for (int ii=1;ii<=this->Nx3(0)+1;ii++) {
+			val = this->Origin(0) + this->Dx3v[0].segment(0,ii-1).sum();
+			xCoords->InsertNextValue(val);
+		}
+		val = this->Origin(1);
+		yCoords->InsertNextValue(val);
+		for (int ii=1;ii<=this->Nx3(1)+1;ii++) {
+			val = this->Origin(1) + this->Dx3v[1].segment(0,ii-1).sum();
+			yCoords->InsertNextValue(val);
+		}
+		val = -1 * this->Origin(2);
+		zCoords->InsertNextValue(val);
+		for (int ii=1;ii<=this->Nx3(2)+1;ii++) {
+			val = this->Origin(2) + this->Dx3v[2].segment(0,ii-1).sum();
+			val = -1*val;
+			zCoords->InsertNextValue(val);
+		}
+
+		vtkRectilinearGrid *rgrid = vtkRectilinearGrid::New();
+		rgrid->SetDimensions(this->Nx3(1)+2,this->Nx3(0)+2,this->Nx3(2)+2);
+		rgrid->SetXCoordinates(yCoords);
+		rgrid->SetYCoordinates(xCoords);
+		rgrid->SetZCoordinates(zCoords);
+
+		vtkRectilinearGridGeometryFilter *plane = 
+			vtkRectilinearGridGeometryFilter::New();
+		plane->SetInputData(rgrid);
+		//plane->SetExtent(0,this->Nx3(0),0,this->Nx3(1),0,this->Nx3(2));
+		//Just for testing
+		plane->SetExtent(0,0,0,this->Nx3(0)+1,0,this->Nx3(2)+1);
+
+		vtkPolyDataMapper *rgridmapper = vtkPolyDataMapper::New();
+		rgridmapper->SetInputConnection(plane->GetOutputPort());
+
+		vtkActor *wireActor = vtkActor::New();
+		wireActor->SetMapper(rgridmapper);
+		wireActor->GetProperty()->SetRepresentationToWireframe();
+		wireActor->GetProperty()->SetColor(0,1,0);
+
+		//Make an actor for each face
+		//Second face
+		vtkRectilinearGridGeometryFilter *plane1 =
+			vtkRectilinearGridGeometryFilter::New();
+		plane1->SetInputData(rgrid);
+		plane1->SetExtent(this->Nx3(1)+1,this->Nx3(1)+1,0,this->Nx3(0)+1,
+			0,this->Nx3(2)+1);
+		vtkPolyDataMapper *rgridmapper1 = vtkPolyDataMapper::New();
+		rgridmapper1->SetInputConnection(plane1->GetOutputPort());
+		vtkActor *wireActor1 = vtkActor::New();
+		wireActor1->SetMapper(rgridmapper1);
+		wireActor1->GetProperty()->SetRepresentationToWireframe();
+		wireActor1->GetProperty()->SetColor(0,1,0);
+		//Third face
+		vtkRectilinearGridGeometryFilter *plane2 =
+			vtkRectilinearGridGeometryFilter::New();
+		plane2->SetInputData(rgrid);
+		plane2->SetExtent(0,this->Nx3(1)+1,0,0,
+			0,this->Nx3(2)+1);
+		vtkPolyDataMapper *rgridmapper2 = vtkPolyDataMapper::New();
+		rgridmapper2->SetInputConnection(plane2->GetOutputPort());
+		vtkActor *wireActor2 = vtkActor::New();
+		wireActor2->SetMapper(rgridmapper2);
+		wireActor2->GetProperty()->SetRepresentationToWireframe();
+		wireActor2->GetProperty()->SetColor(0,1,0);
+		//Fourth face
+		vtkRectilinearGridGeometryFilter *plane3 =
+			vtkRectilinearGridGeometryFilter::New();
+		plane3->SetInputData(rgrid);
+		plane3->SetExtent(0,this->Nx3(1)+1,this->Nx3(0)+1,this->Nx3(0)+1,
+			0,this->Nx3(2)+1);
+		vtkPolyDataMapper *rgridmapper3 = vtkPolyDataMapper::New();
+		rgridmapper3->SetInputConnection(plane3->GetOutputPort());
+		vtkActor *wireActor3 = vtkActor::New();
+		wireActor3->SetMapper(rgridmapper3);
+		wireActor3->GetProperty()->SetRepresentationToWireframe();
+		wireActor3->GetProperty()->SetColor(0,1,0);
+		//Fifth face
+		vtkRectilinearGridGeometryFilter *plane4 =
+			vtkRectilinearGridGeometryFilter::New();
+		plane4->SetInputData(rgrid);
+		plane4->SetExtent(0,this->Nx3(1)+1,0,this->Nx3(0)+1,
+			0,0);
+		vtkPolyDataMapper *rgridmapper4 = vtkPolyDataMapper::New();
+		rgridmapper4->SetInputConnection(plane4->GetOutputPort());
+		vtkActor *wireActor4 = vtkActor::New();
+		wireActor4->SetMapper(rgridmapper4);
+		wireActor4->GetProperty()->SetRepresentationToWireframe();
+		wireActor4->GetProperty()->SetColor(0,1,0);
+		//Sixth face
+		vtkRectilinearGridGeometryFilter *plane5 =
+			vtkRectilinearGridGeometryFilter::New();
+		plane5->SetInputData(rgrid);
+		plane5->SetExtent(0,this->Nx3(1)+1,0,this->Nx3(0)+1,
+			this->Nx3(2)+1,this->Nx3(2)+1);
+		vtkPolyDataMapper *rgridmapper5 = vtkPolyDataMapper::New();
+		rgridmapper5->SetInputConnection(plane5->GetOutputPort());
+		vtkActor *wireActor5 = vtkActor::New();
+		wireActor5->SetMapper(rgridmapper5);
+		wireActor5->GetProperty()->SetRepresentationToWireframe();
+		wireActor5->GetProperty()->SetColor(0,1,0);
+		
+		vtkSmartPointer<vtkOutlineFilter> outlineFilter = 
+			vtkSmartPointer<vtkOutlineFilter>::New();
+		outlineFilter->SetInputData(rgrid);
+		vtkSmartPointer<vtkDataSetMapper> outlinemapper = 
+			vtkSmartPointer<vtkDataSetMapper>::New();
+		outlinemapper->SetInputConnection(outlineFilter->GetOutputPort());
+
+		vtkActor *outlineActor = vtkActor::New();
+		outlineActor->SetMapper(outlinemapper);
+
+		vtkRenderer *renderer = vtkRenderer::New();
+		vtkRenderWindow *renWin = vtkRenderWindow::New();
+		renWin->AddRenderer(renderer);
+		vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
+		iren->SetRenderWindow(renWin);
+
+		renderer->AddActor(wireActor);
+		//renderer->AddActor(wireActor1);
+		renderer->AddActor(wireActor2);
+		//renderer->AddActor(wireActor3);
+		//renderer->AddActor(wireActor4);
+		renderer->AddActor(wireActor5);
+		renderer->AddActor(outlineActor);
+		renderer->SetBackground(0,0,0);
+		renderer->ResetCamera();
+		renderer->GetActiveCamera()->Elevation(40.0);
+		renderer->GetActiveCamera()->Azimuth(15);
+		renderer->GetActiveCamera()->Roll(200);
+		renderer->GetActiveCamera()->Zoom(1.0);
+
+		renWin->SetSize(900,900);
+
+		renWin->Render();
+		iren->Start();
+
+
+
+
+
+	}
+
+
+
+
+}

src/structuredgrid.cpp

@@ -0,0 +1,470 @@
+// ===========================================================================
+// 
+//       Filename:  structuredgrid.cpp
+// 
+//    Description:  
+// 
+//        Version:  0.0
+//        Created:  09/12/2013 08:36:55 AM
+//       Revision:  none
+//       Compiler:  Tested with g++ 
+// 
+//         Author:  M. Andy Kass (MAK)
+//
+//   Organisation:  US Geological Survey
+//                  
+//
+//          Email:  mkass@usgs.gov
+// 
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ===========================================================================
+
+#include "structuredgrid.h"
+
+namespace formalhaut {
+
+	std::ostream &operator<<(std::ostream &stream,
+		const StructuredGrid &ob) {
+		stream << "Class: StructuredGrid\n";
+
+		return stream;
+	}
+
+	StructuredGrid::StructuredGrid() : LogObj(NULL) {
+
+	}
+
+	StructuredGrid::~StructuredGrid() {
+
+	}
+
+	void StructuredGrid::SetNCells(const Eigen::Matrix<int,3,1>& ncells) {
+		this->Nx3 = ncells;
+	}
+
+	void StructuredGrid::SetOrigin(const Vector3r& origin) {
+		this->Origin = origin;
+	}
+
+	void StructuredGrid::ReadMeshtoolsGrid(const std::string& fname) {
+
+		Eigen::Matrix<int,3,1> tn;
+		Vector3r to;
+		VectorXr dx;
+		VectorXr dy;
+		VectorXr dz;
+
+		int adds = 0;
+		int multiplier;
+		int bufsize;
+		std::string temp;
+		std::string temp2;
+		std::string tast;
+		char* commentBuffer = new char[200];
+
+		bufsize = 200;
+		std::fstream infile(fname.c_str(),std::ios::in);
+		if (infile.fail()) {
+			throw GenericFileIOError(fname);
+		}
+		infile.getline(commentBuffer,bufsize);
+		temp = commentBuffer;
+		std::istringstream in(temp);
+		for (int ii=0;ii<3;ii++) {
+			in >> tn(ii);
+		}
+		in.clear();
+
+		infile.getline(commentBuffer,bufsize);
+		temp = " ";
+		temp = commentBuffer;
+		std::istringstream in2(temp);
+		for (int ii=0;ii<=2;ii++) {
+			in2 >> to(ii);
+		}
+		in2.clear();
+
+		dx.resize(tn(0));
+		dy.resize(tn(1));
+		dz.resize(tn(2));
+
+		infile.getline(commentBuffer,bufsize);
+		temp = commentBuffer;
+		in.str(temp.c_str());
+		int ii = 0;
+		Real t2;
+		while (ii <=tn(0)-1) {
+			in >> t2;
+			tast = in.peek();
+			if (tast=="*") {
+				temp2 = in.get();
+				multiplier = t2;
+				in >> t2;
+				for (int jj=0;jj<=multiplier-2;jj++) {
+					dx(ii+jj) = t2;
+					adds = jj;
+				}
+				ii = ii+adds+1;
+			}
+			dx(ii) = t2;
+			ii++;
+		}
+
+		infile.getline(commentBuffer,bufsize);
+		temp = commentBuffer;
+		in.str(temp.c_str());
+		ii = 0;
+		adds = 0;
+		while (ii <=tn(1)-1) {
+			in >> t2;
+			tast = in.peek();
+			if (tast=="*") {
+				temp2 = in.get();
+				multiplier = t2;
+				in >> t2;
+				for (int jj=0;jj<=multiplier-2;jj++) {
+					dy(ii+jj) = t2;
+					adds = jj;
+				}
+				ii = ii+adds+1;
+			}
+			dy(ii) = t2;
+			ii++;
+		}
+
+		infile.getline(commentBuffer,bufsize);
+		temp = commentBuffer;
+		in.str(temp.c_str());
+		ii = 0;
+		adds = 0;
+		while (ii <=tn(2)-1) {
+			in >> t2;
+			tast = in.peek();
+			if (tast=="*") {
+				temp2 = in.get();
+				multiplier = t2;
+				in >> t2;
+				for (int jj=0;jj<=multiplier-2;jj++) {
+					dz(ii+jj) = t2;
+					adds = jj;
+				}
+				ii = ii+adds+1;
+			}
+			dz(ii) = t2;
+			ii++;
+		}
+
+		
+
+/*		
+		infile.getline(commentBuffer,bufsize);
+		temp = commentBuffer;
+		in.str(temp.c_str());
+		int ii = 0;
+		while (ii <= tn(0)-1) {
+			in >> dx(ii);
+			std::cout << dx(ii) << std::endl;
+			ii++;
+			tast = in.peek();
+			if (tast=="*") {
+				temp2 = in.get();
+				in >> multiplier;
+				std::cout << multiplier << std::endl;
+				for (int jj=0;jj<=multiplier-2;jj++) {
+					dx(ii+jj) = dx(ii-1);
+					adds = jj;
+				}
+				ii = ii+adds+1;
+			}
+		}
+		in.clear();
+
+		infile.getline(commentBuffer,bufsize);
+		temp = commentBuffer;
+		in.str(temp.c_str());
+		ii = 0;
+		adds = 0;
+		while (ii <= tn(1)-1) {
+			in >> dy(ii);
+			ii++;
+			tast = in.peek();
+			if (tast == "*") {
+				temp2 = in.get();
+				in >> multiplier;
+				for (int jj=0;jj<=multiplier-2;jj++) {
+					dy(ii+jj) = dy(ii-1);
+					adds = jj;
+				}
+				ii = ii+adds+1;
+			}
+		}
+		in.clear();
+
+		infile.getline(commentBuffer,bufsize);
+		temp = commentBuffer;
+		in.str(temp.c_str());
+		ii = 0;
+		adds = 0;
+		while (ii <= tn(2)-1) {
+			in >> dz(ii);
+			ii++;
+			tast = in.peek();
+			if (tast=="*") {
+				temp2=in.get();
+				in >> multiplier;
+				for (int jj=0;jj<=multiplier-2;jj++) {
+					dz(ii+jj) = dz(ii-1);
+					adds = jj;
+				}
+				ii = ii+adds+1;
+			}
+		}
+		in.clear();
+*/
+		infile.close();
+		delete [] commentBuffer;
+
+		this->Origin = to;
+		this->Nx3 = tn;
+
+		if (this->TypeOfGrid == regular) {
+			// Check to make sure mesh is regular
+			for (int jj=0;jj<this->Nx3(0);jj++) {
+				if (dx(0) != dx(jj)) {
+					std::cout << "Error!  Non-regular mesh read into " <<
+						"regular mesh object.  Exiting." << std::endl;
+					exit(EXIT_FAILURE);
+				}
+			}
+			for (int jj=0;jj<this->Nx3(1);jj++) {
+				if (dy(0) != dy(jj)) {
+					std::cout << "Error!  Non-regular mesh read into " <<
+						"regular mesh object.  Exiting." << std::endl;
+					exit(EXIT_FAILURE);
+				}
+			}
+			for (int jj=0;jj<this->Nx3(2);jj++) {
+				if (dz(0) != dz(jj)) {
+					std::cout << "Error!  Non-regular mesh read into " <<
+						"regular mesh object.  Exiting." << std::endl;
+					exit(EXIT_FAILURE);
+				}
+			}
+
+			// Resize Dx3 and populate
+			this->Dx3.resize(Eigen::NoChange,1);
+			this->Dx3(0) = dx(0);
+			this->Dx3(1) = dy(0);
+			this->Dx3(2) = dz(0);
+
+			// Write to log file
+			std::string logw;
+			std::stringstream ss;
+			std::vector<std::string> logs;
+			this->LogObj->WriteLogLine("Regular Mesh parameters:");
+			logw = "nx\t\tny\t\tnz\t\tdx\t\tdy\t\tdz\t\tox\t\toy\t\toz";
+			this->LogObj->WriteLogLine(logw);
+			this->LogObj->WriteDashedLine();
+			ss << this->Nx3(0);
+			logs.push_back(ss.str());
+			ss.str("");
+			ss << this->Nx3(1);
+			logs.push_back(ss.str());
+			ss.str("");
+			ss << this->Nx3(2);
+			logs.push_back(ss.str());
+			ss.str("");
+			ss << this->Dx3(0);
+			logs.push_back(ss.str());
+			ss.str("");
+			ss << this->Dx3(1);
+			logs.push_back(ss.str());
+			ss.str("");
+			ss << this->Dx3(2);
+			logs.push_back(ss.str());
+			ss.str("");
+			ss << this->Origin(0);
+			logs.push_back(ss.str());
+			ss.str("");
+			ss << this->Origin(1);
+			logs.push_back(ss.str());
+			ss.str("");
+			ss << this->Origin(2);
+			logs.push_back(ss.str());
+			ss.str("");
+			logw = "";
+			for (int jj=0;jj<9;jj++) {
+				logw = logw + logs[jj] + "\t\t";
+			}
+			this->LogObj->WriteLogLine(logw);
+			this->LogObj->WriteLogLine("\n");
+			
+
+		}
+		else if (this->TypeOfGrid == rectilinear) {
+			this->Dx3v.push_back(dx);
+			this->Dx3v.push_back(dy);
+			this->Dx3v.push_back(dz);
+
+			// Write to log file
+			std::string logw;
+			std::stringstream ss;
+			std::vector<std::string> logs;
+			this->LogObj->WriteLogLine("Rectilinear Mesh Parameters:");
+			logw = "nx\t\tny\t\tnz\t\tox\t\toy\t\toz";
+			this->LogObj->WriteLogLine(logw);
+			this->LogObj->WriteDashedLine();
+			ss << this->Nx3(0);
+			logs.push_back(ss.str());
+			ss.str("");
+			ss << this->Nx3(1);
+			logs.push_back(ss.str());
+			ss.str("");
+			ss << this->Nx3(2);
+			logs.push_back(ss.str());
+			ss.str("");
+			ss << this->Origin(0);
+			logs.push_back(ss.str());
+			ss.str("");
+			ss << this->Origin(1);
+			logs.push_back(ss.str());
+			ss.str("");
+			ss << this->Origin(2);
+			logs.push_back(ss.str());
+			ss.str("");
+			logw = "";
+			for (int jj=0;jj<6;jj++) {
+				logw = logw + logs[jj] + "\t\t";
+			}
+			this->LogObj->WriteLogLine(logw);
+			this->LogObj->WriteLogLine("\n");
+
+
+		}
+		else if (this->TypeOfGrid == octree) {
+			std::cout << "Error!  Octree mesh object cannot interface " <<
+				"with Meshtools format.  Exiting." << std::endl;
+			exit(EXIT_FAILURE);
+		}
+		else {
+			std::cout << "Error!  Mesh object not declared properly. Exiting."
+				<< std::endl << "(will try to be more unhelpful in the "
+				<< "future)" << std::endl;
+			exit(EXIT_FAILURE);
+		}
+
+
+	}
+
+	void StructuredGrid::AttachLogObject(Logging* logobj) {
+		this->LogObj = logobj;
+	}
+
+	int StructuredGrid::GetVectorPosition(const Eigen::Matrix<int,3,1>& 
+		cellpos) {
+
+		int vecpos;
+
+		// Check and make sure the points are valid
+		if (cellpos(0) >= this->Nx3(0)) {
+			std::cout << "Invalid queried vector position in x dim\n";
+			exit(EXIT_FAILURE);
+		}
+		if (cellpos(1) >= this->Nx3(1)) {
+			std::cout << "Invalid queried vector position in y dim\n";
+			exit(EXIT_FAILURE);
+		}
+		if (cellpos(2) >= this->Nx3(2)) {
+			std::cout << "Invalid queried vector position in z dim\n";
+			exit(EXIT_FAILURE);
+		}
+
+		// z changes first, then x, then y
+		vecpos = (cellpos(1)*this->Nx3(0)*this->Nx3(2)) +
+			(cellpos(0)*this->Nx3(2)) + cellpos(2);
+
+		return vecpos;
+	}
+
+	int StructuredGrid::QueryCellPosition(const Vector3r& cellpos) {
+		int vecpos;
+		Vector3r cellposmo;
+
+		//Check to make sure the point is in the model region
+		if (cellpos(0) < this->Origin(0) || cellpos(0) >= 
+			this->Nx3(0)*this->Dx3(0) + this->Origin(0)) {
+			std::cout << "Queried point exists outside model region.\n";
+			std::cout << "Given location: " << cellpos(0) << "\n"
+				<< "Region limits: " << this->Origin(0) << " to " <<
+				this->Nx3(0)*this->Dx3(0)+this->Origin(0) << std::endl;
+			exit(EXIT_FAILURE);
+		}
+		
+		if (cellpos(1) < this->Origin(1) || cellpos(1) >= 
+			this->Nx3(1)*this->Dx3(1) + this->Origin(1)) {
+			std::cout << "Queried point exists outside model region.\n";
+			std::cout << "Given location: " << cellpos(1) << "\n"
+				<< "Region limits: " << this->Origin(1) << " to " <<
+				this->Nx3(1)*this->Dx3(1)+this->Origin(1) << std::endl;
+			exit(EXIT_FAILURE);
+		}
+
+		if (cellpos(2) < this->Origin(2) || cellpos(2) >= 
+			this->Nx3(2)*this->Dx3(2) + this->Origin(2)) {
+			std::cout << "Queried point exists outside model region.\n";
+			std::cout << "Given location: " << cellpos(2) << "\n"
+				<< "Region limits: " << this->Origin(2) << " to " <<
+				this->Nx3(2)*this->Dx3(2)+this->Origin(2) << std::endl;
+			exit(EXIT_FAILURE);
+		}
+
+		//Subtract off the origin just to make the maths easier
+		for (int ii=0;ii<3;ii++) {
+			cellposmo(ii) = cellpos(ii) - this->Origin(ii);
+		}
+
+		vecpos = 42;
+		/// \todo Finish this up.  Returning 42 right now.
+		return vecpos;		
+	}
+
+	Eigen::Matrix<int,3,1> StructuredGrid::GetNCells() {
+		return this->Nx3;
+	}
+
+	Vector3r StructuredGrid::GetOrigin() {
+		return this->Origin;
+	}
+
+	Vector3Xr StructuredGrid::GetCentroids() {
+		return this->VecCentroid;
+	}
+
+	Vector3r StructuredGrid::GetCentroid(const int& vecpos) {
+		return this->VecCentroid.row(vecpos);
+	}
+
+
+
+
+
+
+
+
+
+
+
+
+}