BasicMeshes.hpp

/*---------------------------------------------------------------------------*\
 *
 *  mimmo
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of mimmo.
 *
 *  mimmo is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  mimmo 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 Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with mimmo. If not, see <http://www.gnu.org/licenses/>.
 *
 \ *---------------------------------------------------------------------------*/
 
#ifndef __BASICMESHES_HH
#define __BASICMESHES_HH
 
#include "BasicShapes.hpp"
#include <memory>
 
namespace mimmo{
 
class UStructMesh{
 
protected:
    std::unique_ptr<BasicShape> m_shape;    
    double              m_dx;   
    double              m_dy;   
    double              m_dz;   
    int                 m_nx;   
    int                 m_ny;   
    int                 m_nz;   
    dvector1D   m_xnode;    
    dvector1D   m_ynode;    
    dvector1D   m_znode;    
    dvector1D   m_xedge;    
    dvector1D   m_yedge;    
    dvector1D   m_zedge;    
    bool                    m_setorigin;        
    bool                    m_setspan;          
    bool                    m_setInfLimits;     
    bool                    m_setRefSys;        
    bool                    m_isBuild;          
private:
    //list of temp members
    darray3E                m_origin_temp;  
    darray3E                m_span_temp;    
    darray3E                m_inflimits_temp; 
    dmatrix33E              m_refsystem_temp; 
    ShapeType               m_shapetype_temp; 
public:
    //Building stuffs
    UStructMesh();
    virtual ~UStructMesh();
 
    // Copy constructor & assignment operators
    UStructMesh(const UStructMesh & other);
    UStructMesh & operator=(UStructMesh other);
 
    void swap(UStructMesh & x) noexcept;
 
    //get-set methods
    const BasicShape*       getShape() const;
    BasicShape*             getShape();
    darray3E                getOrigin();
    darray3E                getSpan();
    darray3E                getInfLimits();
    dmatrix33E              getRefSystem();
    darray3E                getScaling();
    darray3E                getLocalSpan();
    ShapeType   getShapeType();
    CoordType   getCoordType(int);
    CoordType   getCoordTypex();
    CoordType   getCoordTypey();
    CoordType   getCoordTypez();
 
    std::array<CoordType,3> getCoordType();
 
    darray3E                getSpacing();
    iarray3E                getDimension();
 
    darray3E                getLocalCCell(int);
    darray3E                getLocalCCell(int, int, int);
    darray3E                getLocalPoint(int);
    darray3E                getLocalPoint(int, int, int);
    darray3E                getGlobalCCell(int);
    darray3E                getGlobalCCell(int, int, int);
    darray3E                getGlobalPoint(int);
    darray3E                getGlobalPoint(int, int, int);
 
    ivector1D               getCellNeighs(int);
    ivector1D               getCellNeighs(int, int, int);
 
    dvecarr3E               getLocalCoords();
    dvecarr3E               getGlobalCoords();
    dvecarr3E               getGlobalCellCentroids();
    dvecarr3E               getLocalCellCentroids();
 
    void    setOrigin(darray3E origin);
    void    setSpan(double, double, double);
    void    setSpan(darray3E span);
    void    setInfLimits(double val, int dir);
    void    setInfLimits(darray3E val);
 
    void    setRefSystem(darray3E, darray3E, darray3E);
    void    setRefSystem(int, darray3E);
    void    setRefSystem(dmatrix33E);
 
    void    setDimension(ivector1D dim);
    void    setDimension(iarray3E dim);
 
    void    setShape(ShapeType type = ShapeType::CUBE);
    void    setShape(int itype = 0);
    void    setShape(const BasicShape *);
 
    void    setCoordType(CoordType,int);
    void    setCoordTypex(CoordType);
    void    setCoordTypey(CoordType);
    void    setCoordTypez(CoordType);
 
    void    setCoordType(std::array<CoordType,3>);
 
    void    setMesh(darray3E & origin, darray3E & span, ShapeType, iarray3E & dimensions);
    void    setMesh(darray3E & origin, darray3E & span, ShapeType, dvector1D & spacing);
    void    setMesh(BasicShape *, iarray3E & dimensions);
    void    setMesh(BasicShape *, dvector1D & spacing);
 
    //generic manteinance of the mesh
    void    clearMesh();
 
    //functionalities
    void    locateCellByPoint(darray3E & point, int &i, int &j, int &k);
    void    locateCellByPoint(dvector1D & point, int &i, int &j, int &k);
    int     accessCellIndex(int i, int j, int k);
    void    accessCellIndex(int N_, int &i, int &j, int &k);
    int     accessPointIndex(int i, int j, int k);
    void    accessPointIndex(int N_, int &i, int &j, int &k);
 
    darray3E    transfToGlobal( darray3E & point);
    dvector1D   transfToGlobal( dvector1D & point);
    dvecarr3E   transfToGlobal( dvecarr3E & list_points);
    darray3E    transfToLocal( darray3E & point);
    dvector1D   transfToLocal( dvector1D & point);
    dvecarr3E   transfToLocal( dvecarr3E & list_points);
 
    // interpolators
    double      interpolateCellData(darray3E & point, dvector1D & celldata);
    int         interpolateCellData(darray3E & point, ivector1D & celldata);
    darray3E    interpolateCellData(darray3E & point, dvecarr3E & celldata);
 
    double      interpolatePointData(darray3E & point, dvector1D & pointdata);
    int         interpolatePointData(darray3E & point, ivector1D & pointdata);
    darray3E    interpolatePointData(darray3E & point, dvecarr3E & pointdata);
 
    //plotting
    void        plotCloud( std::string & , std::string, int , bool, const ivector1D & labels, dvecarr3E * extPoints=nullptr);
    void        plotCloudScalar(std::string, std::string , int, bool, dvector1D & data);
    void        plotGrid(std::string &, std::string , int, bool, const ivector1D & labels, dvecarr3E * extPoints=nullptr);
    void        plotGridScalar(std::string, std::string , int, bool, dvector1D & data);
 
    void        execute();
    bool        isBuilt();
 
    virtual bool        build();
 
protected:
    //internal maintenance of the mesh
    void        resizeMesh();
    void        destroyNodalStructure();
    void        reshapeNodalStructure();
 
};
 
 
inline int  UStructMesh::accessPointIndex(int i, int j, int k){
    int index = (m_ny+1) * (m_nz+1) * i + (m_nz+1) * j + k;
    return(index);
};
 
};
 
#endif //__BASICMESHES_HH