geom.h

Go to the documentation of this file.

#ifndef GEOM_FILE
#define GEOM_FILE
#include <array>
#include <functional>             // function; C++11
#include <string>
#include <vector>
 
class Mesh
{
public:
    explicit Mesh(int ndim, int nvert_e = 0, int ndof_e = 0);
 
    virtual ~Mesh();
 
    int Nelems() const
    {
        return _nelem;
    }
 
    int NverticesElements() const
    {
        return _nvert_e;
    }
 
    int NdofsElement() const
    {
        return _ndof_e;
    }
 
    int Nnodes() const
    {
        return _nnode;
    }
 
    int Ndims() const
    {
        return _ndim;
    }
 
    void Resize_Connectivity(int nelem, int nvert_e)
    {
        SetNelem(nelem);               // number of elements
        SetNverticesElement(nvert_e);  // vertices per element
        _ia.resize(nelem * nvert_e);
    }
 
    const std::vector<int>  &GetConnectivity() const
    {
        return _ia;
    }
 
    std::vector<int>  &GetConnectivity()
    {
        return _ia;
    }
 
    void Resize_Coords(int nnodes, int ndim)
    {
        SetNnode(nnodes);       // number of nodes
        SetNdim(ndim);          // space dimension
        _xc.resize(nnodes * ndim);
    }
 
    const std::vector<double> &GetCoords() const
    {
        return _xc;
    }
 
    std::vector<double> &GetCoords()
    {
        return _xc;
    }
 
    void SetValues(std::vector<double> &v, const std::function<double(double, double)> &func) const;
 
    void Debug() const;
 
    virtual std::vector<int> Index_DirichletNodes() const = 0;
 
    void Write_ascii_matlab(std::string const &fname, std::vector<double> const &v) const;
 
    void Visualize(std::vector<double> const &v) const;
 
 
protected:
    void SetNelem(int nelem)
    {
        _nelem = nelem;
    }
 
    void SetNverticesElement(int nvert)
    {
        _nvert_e = nvert;
    }
 
    void SetNdofsElement(int ndof)
    {
        _ndof_e = ndof;
    }
 
    void SetNnode(int nnode)
    {
        _nnode = nnode;
    }
 
    void SetNdim(int ndim)
    {
        _ndim = ndim;
    }
 
private:
    int _nelem;         
    int _nvert_e;       
    int _ndof_e;        
    int _nnode;         
    int _ndim;          
    std::vector<int> _ia;    
    std::vector<double> _xc; 
};
 
class Mesh_2d_3_square: public Mesh
{
public:
    Mesh_2d_3_square(int nx, int ny, int myid = 0, int procx = 1, int procy = 1);
 
    ~Mesh_2d_3_square() override
    {}
 
    void SetU(std::vector<double> &u) const;
 
    void SetF(std::vector<double> &f) const;
 
    std::vector<int> Index_DirichletNodes() const override;
 
    void SaveVectorP(std::string const &name, std::vector<double> const &u) const;
 
    // here will still need to implement in the class
    //  GetBound(), AddBound()
    //  or better a generalized way with indices and their appropriate ranks for MPI communication
 
private:
    void GetCoordsInRectangle(int nx, int ny, double xl, double xr, double yb, double yt,
                              double xc[]);
    void GetConnectivityInRectangle(int nx, int ny, int ia[]);
 
private:
    int _myid;          
    int _procx;         
    int _procy;         
    std::array<int, 4> _neigh; 
    int _color;         
 
    double _xl;         
    double _xr;         
    double _yb;         
    double _yt;         
    int    _nx;         
    int    _ny;         
};
 
// #################### still some old code (--> MPI) ############################
// GH_NOTE: Absicherung bei s !!
void GetBound(int ib, int nx, int ny, double const w[], double s[]);
 
 
void AddBound(int ib, int nx, int ny, double w[], double const s[]);
 
// #################### Mesh from Matlab ############################
class Mesh_2d_3_matlab: public Mesh
{
public:
    explicit Mesh_2d_3_matlab(std::string const &fname);
 
    std::vector<int> Index_DirichletNodes() const override;
 
private:
    int Nnbedges() const
    {
        return static_cast<int>(bedges.size());
    }
 
    std::vector<int> bedges;     
 
};
 
#endif