meshgrid.h

/*************************************************************************************
 * MechSys - A C++ library to simulate (Continuum) Mechanical Systems                *
 * Copyright (C) 2005 Dorival de Moraes Pedroso <dorival.pedroso at gmail.com>       *
 * Copyright (C) 2005 Raul Dario Durand Farfan  <raul.durand at gmail.com>           *
 *                                                                                   *
 * This file is part of MechSys.                                                     *
 *                                                                                   *
 * MechSys 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 2 of the License, or (at your option) any later        *
 * version.                                                                          *
 *                                                                                   *
 * MechSys 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      *
 * MechSys; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, *
 * Fifth Floor, Boston, MA 02110-1301, USA                                           *
 *************************************************************************************/

#ifndef MECHSYS_MESHGRID_H
#define MECHSYS_MESHGRID_H

#ifdef HAVE_CONFIG_H
  #include "config.h"
#else
  #ifndef REAL
    #define REAL double
  #endif
#endif

#include <iostream>
#include <cassert>

class MeshGrid
{
public:
    MeshGrid(REAL StartX, REAL EndX, REAL StepX,
             REAL StartY, REAL EndY, REAL StepY);

    MeshGrid(REAL StartX, REAL EndX, int nX,
             REAL StartY, REAL EndY, int nY); // nX and nY must be equal to or greater than 1

    MeshGrid(REAL StartX, REAL EndX, int nX,
             REAL StartY, REAL EndY, int nY,
             REAL StartZ, REAL EndZ, int nZ); // nX and nY must be equal to or greater than 1

    ~MeshGrid()
    {
        if (_X!=NULL) delete [] _X; 
        if (_Y!=NULL) delete [] _Y; 
        if (_Z!=NULL) delete [] _Z; 
    }

    int      nX() const {                    return _nX;     }
    int      nY() const {                    return _nY;     }
    int      nZ() const {                    return _nZ;     }
    int  Length() const {                    return _length; }
    REAL X(int i) const { assert(_X!=NULL);  return _X[i];   }
    REAL Y(int i) const { assert(_Y!=NULL);  return _Y[i];   }
    REAL Z(int i) const { assert(_Z!=NULL);  return _Z[i];   }

    REAL const * X() const { assert(_X!=NULL);  return _X;   }
    REAL const * Y() const { assert(_Y!=NULL);  return _Y;   }
    REAL const * Z() const { assert(_Z!=NULL);  return _Z;   }

private:
    int    _nX;
    int    _nY;
    int    _nZ;
    int    _length;
    REAL * _X;
    REAL * _Y;
    REAL * _Z;
}; // class MeshGrid

std::ostream & operator<< (std::ostream & os, MeshGrid & mg);




inline MeshGrid::MeshGrid(REAL StartX, REAL EndX, REAL StepX, // {{{
                          REAL StartY, REAL EndY, REAL StepY)
    : _nX(0), _nY(0), _nZ(0), _length(0), _X(NULL), _Y(NULL), _Z(NULL)
{
    REAL NumX = (EndX-StartX+StepX)/StepX;
    REAL NumY = (EndY-StartY+StepY)/StepY;
    assert(NumX>=1);
    assert(NumY>=1);
    
    int nX = static_cast<int>(NumX);
    int nY = static_cast<int>(NumY);

        _nX = nX;
        _nY = nY;
    _length = nX*nY;
    
    _X = new REAL [_length];
    _Y = new REAL [_length];

    int    k=0;
    REAL X;
    REAL Y=StartY;
    for (int j=0; j<nY; ++j)
    {
        X=StartX;
        for (int i=0; i<nX; ++i)
        {
            _X[k] = X;
            _Y[k] = Y;
            X=X+StepX;
            k++;
        }
        Y=Y+StepY;
    }
} // }}}

inline MeshGrid::MeshGrid(REAL StartX, REAL EndX, int nX, // {{{
                          REAL StartY, REAL EndY, int nY)
    : _nX(0), _nY(0), _nZ(0), _length(0), _X(NULL), _Y(NULL), _Z(NULL)
{
    assert(nX>=1);
    assert(nY>=1);
    REAL StepX = ( nX>1 ? (EndX-StartX)/(nX-1.0) : 0.0 );
    REAL StepY = ( nY>1 ? (EndY-StartY)/(nY-1.0) : 0.0 );

        _nX = nX;
        _nY = nY;
    _length = nX*nY;
    
    _X = new REAL [_length];
    _Y = new REAL [_length];

    int  k=0;
    REAL X;
    REAL Y=StartY;
    for (int j=0; j<nY; ++j)
    {
        X=StartX;
        for (int i=0; i<nX; ++i)
        {
            _X[k] = X;
            _Y[k] = Y;
            X=X+StepX;
            k++;
        }
        Y=Y+StepY;
    }
} // }}}

inline MeshGrid::MeshGrid(REAL StartX, REAL EndX, int nX, // {{{
                          REAL StartY, REAL EndY, int nY,
                          REAL StartZ, REAL EndZ, int nZ)
    : _nX(0), _nY(0), _nZ(0), _length(0), _X(NULL), _Y(NULL), _Z(NULL)
{
    assert(nX>=1);
    assert(nY>=1);
    assert(nZ>=1);
    REAL StepX = ( nX>1 ? (EndX-StartX)/(nX-1.0) : 0.0 );
    REAL StepY = ( nY>1 ? (EndY-StartY)/(nY-1.0) : 0.0 );
    REAL StepZ = ( nZ>1 ? (EndZ-StartZ)/(nZ-1.0) : 0.0 );

        _nX = nX;
        _nY = nY;
        _nZ = nZ;
    _length = nX*nY*nZ;
    
    _X = new REAL [_length];
    _Y = new REAL [_length];
    _Z = new REAL [_length];

    int  p=0;
    REAL X;
    REAL Y;
    REAL Z=StartZ;
    for (int k=0; k<nZ; ++k)
    {
        Y=StartY;
        for (int j=0; j<nY; ++j)
        {
            X=StartX;
            for (int i=0; i<nX; ++i)
            {
                _X[p] = X;
                _Y[p] = Y;
                _Z[p] = Z;
                X=X+StepX;
                p++;
            }
            Y=Y+StepY;
        }
        Z=Z+StepZ;
    }
} // }}}

std::ostream & operator<< (std::ostream & os, MeshGrid & mg) // {{{
{
    for (int i=0; i<mg.Length(); ++i)
    {
        if (mg.nX()>0) os << mg.X(i) << "   ";
        if (mg.nY()>0) os << mg.Y(i) << "   ";
        if (mg.nZ()>0) os << mg.Z(i) << "   ";
        os << std::endl;
    }
    return os;
} // }}}

#endif // MECHSYS_MESHGRID_H

// vim:fdm=marker

---