C++ newbie qu: grid construction for finite difference

[bzz77]

Hello everyone:

I am a C++ newbie; I am interesting in using C++ in my work on coupled fluid flow-chemical reaction problems. I apologize in advance for what is probably a very simple question. I would very much appreciate any help to get me on the right track!

My goal is to come up with C++ code for solving a finite difference problem. To do this, I need to (1) construct a 2-D grid and (2) link a struct of data (fluid properties, like density) to the grid. At some point, as I become more experienced, I'd like to learn how to use pointers and iterators, etc, but for now I would like to keep things as simple as possible.

Using some examples, I have come up with a way of constructing a grid that mostly makes sense. But I cannot figure out how to link the grid with a struct of fluid properties. Sorry--I'm certain this is a simple thing to do. If anyone has any suggestions, I would love to hear them. Once I have this problem sorted out, I have a couple of further questions about the grid construction. Thanks a lot.

Here is my grid:

template <typename T>
class Grid2D
{
public:
Grid() : xsize_(0), ysize_(0), grid_(0) { }
Grid(double xsize, double ysize) : xsize_(xsize), ysize_(ysize), grid_(new T[ xsize_ * ysize_ ]) { }

~Grid() { delete[ ] grid_; }
Create(double xsize, double ysize)
{
xsize_ = xsize;
ysize_ = ysize;
grid_ = new T[ xsize_ * ysize_ ];
}
Resize(double xsize, double ysize)
{
xsize_ = xsize;
ysize_ = ysize;
delete[ ] grid_;
grid_ = new T[ xsize_ * ysize_ ];
}
Delete()
{
xsize_ = 0;
ysize_ = 0;
delete[ ] grid_;
grid_ = 0;
}
double xsize() const { return xsize_; }
double ysize() const { return ysize_; }
T& operator(double x, double y) { return grid_[ y*xsize_ + x ]; }
const T& operator(double x, double y) const { return grid_[ y*xsize_ + x ]; }
private:
double xsize_, ysize_;
T* grid_;
}

 

[ilh]

To link the grid with a struct of fluid properties, you could create a class that contains both the Grid2D and the struct. For example: class GridFluid{public:GridFluid() : grid_(0), fluidProperties_(0) {}GridFluid(double xsize, double ysize) : grid_(xsize, ysize), fluidProperties_() {}~GridFluid() { delete[ ] grid_; } Grid& grid() { return grid_; } const Grid& grid() const { return grid_; } FluidProperties& fluidProperties() { return fluidProperties_; } const FluidProperties& fluidProperties() const { return fluidProperties_; } private: Grid grid_;FluidProperties fluidProperties_;};Now when you need to access the fluid properties, you can simply call the GridFluid object and use the .fluidProperties() method. Hope this helps!

 

[quicknote]

Hello,

First of all, welcome to the world of C++! It's great to see someone interested in using this powerful language in their scientific work.

To answer your question, you can link a struct of fluid properties to your grid by creating a new struct that contains both the grid and the fluid properties. For example, you could create a struct called "FluidGrid" that has two members - a Grid2D object and a struct containing your fluid properties. This way, you can access both the grid and the fluid properties through one object.

As for your further questions about grid construction, I would suggest looking into using multi-dimensional arrays instead of a single-dimensional array for your grid. This can make it easier to access and manipulate individual cells within the grid.

Also, as you mentioned, learning about pointers and iterators will definitely help you in writing more efficient and flexible code. I would recommend practicing with some simple examples to get more comfortable with them.

I hope this helps and good luck with your work! Don't hesitate to reach out for more help if needed.