MimmoGeometry.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 __MIMMOGEOMETRY_HPP__
#define __MIMMOGEOMETRY_HPP__
 
#include "BaseManipulation.hpp"
#include "enum.hpp"
#include <typeinfo>
#include <type_traits>
 
BETTER_ENUM(FileType, int, STL = 0, SURFVTU = 1, VOLVTU = 2, NAS = 3, PCVTU = 4, CURVEVTU = 5, MIMMO = 99);
 
BETTER_ENUM(NastranElementType, int, GRID = 0, CTRIA = 1, CQUAD = 2, CBAR = 3, RBE2 = 4, RBE3 = 5);
 
namespace mimmo{
 
class NastranInterface;
 
enum WFORMAT{
    Short = 0, 
    Long =  1  
};
 
 
// TODO ADD CUSTOM NUMBER OF PROCESSORS FOR INPUT/OUTPUT OF VTU FILES
class MimmoGeometry: public BaseManipulation{
 
protected:
    bool         m_read;         
    FileDataInfo m_rinfo;       
    bool         m_write;         
    FileDataInfo m_winfo;       
    bool        m_codex;                    
    WFORMAT        m_wformat;                    
    bool        m_buildSkdTree;             
    bool        m_buildKdTree;                
    long        m_refPID;                     
    bool        m_multiSolidSTL;            
    double      m_tolerance;                
    bool        m_clean;                    
    bool        m_parallelRestore;               
public:
    enum class IOMode{
        READ = 0,    
        WRITE = 1,   
        CONVERT = 2 
    };
 
    MimmoGeometry(IOMode mode = IOMode::READ);
    MimmoGeometry(const bitpit::Config::Section & rootXML);
    virtual ~MimmoGeometry();
 
    MimmoGeometry(const MimmoGeometry & other);
    MimmoGeometry & operator=(MimmoGeometry other);
 
    void buildPorts();
 
    const MimmoGeometry *    getCopy();
 
public:
    void        setReadDir(std::string dir);
    void        setWriteDir(std::string dir);
    void        setReadFilename(std::string filename);
    void        setWriteFilename(std::string filename);
 
    void        setDir(std::string dir);
    void        setFilename(std::string filename);
    void        setReadFileType(FileType type);
    void        setReadFileType(int type);
    void        setWriteFileType(FileType type);
    void        setWriteFileType(int type);
    void        setFileType(FileType type);
    void        setFileType(int type);
    void        setCodex(bool binary = true);
    void        setMultiSolidSTL(bool multi = true);
 
    void        setTolerance(double tol);
    void        setClean(bool clean = true);
    void        setParallelRestore(bool parallelRestore = MIMMO_ENABLE_MPI);
 
    using BaseManipulation::setGeometry;
    void        setGeometry(int type=1);
 
    bitpit::PiercedVector<bitpit::Vertex> *     getVertices();
    bitpit::PiercedVector<bitpit::Cell> *         getCells();
 
 
    void        setPID(livector1D pids);
    void        setPID(std::unordered_map<long,long> pidsMap);
    void        setReferencePID(long pid);
 
    void        setFormatNAS(WFORMAT wform);
 
    void        setBuildSkdTree(bool build);
    void        setBuildKdTree(bool build);
 
    bool         isEmpty();
    void         clear();
    bool        write();
    bool        read();
 
    void         execute();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="");
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="");
 
protected:
    void swap(MimmoGeometry & x) noexcept;
    void        setIOMode(IOMode mode);
    void        setIOMode(int mode);
    void    setDefaults();
    void    _setRead(bool read = true);
    void    _setWrite(bool write = true);
    bool   fileExist(const std::string & filename);
 
};
 
class NastranInterface{
    static const char nl = '\n'; 
public:
 
    WFORMAT    m_wformat; 
    std::map<NastranElementType, bool> m_enabled; 
    NastranInterface();
 
    void setWFormat(WFORMAT);
    void writeKeyword(std::string key, std::ofstream& os);
    void writeCoord(const darray3E & p, const long& pointI, std::ofstream& os);
    void writeFace(std::string faceType, const livector1D& facePts, const long& nFace, std::ofstream& os, long PID);
    bool writeGeometry(dvecarr3E &points,livector1D &pointsID, livector2D &faces, livector1D &facesID, std::ofstream &os, livector1D *PIDS = nullptr);
    void writeFooter(std::ofstream& os, std::unordered_set<long>* PIDSSET = nullptr);
    void write(std::string& outputDir, std::string& surfaceName, dvecarr3E& points, livector1D& pointsID, livector2D& faces, livector1D& facesID, livector1D* PIDS = nullptr, std::unordered_set<long>* PIDSSET = nullptr);
    void read(std::string& inputDir, std::string& surfaceName, dvecarr3E& points, livector1D& pointsID, livector2D& faces, livector1D& facesID, livector1D& PIDS);
 
    std::string trim(std::string in);
    std::string convertVertex(std::string in);
 
    void appendLineRecords(std::string & sread, std::size_t recordlength, std::vector<std::string> & records);
    void absorbRBE2(std::vector<std::string> & records, long & ID, long & PID, std::vector<long> & connectivity, std::string & components);
    void absorbRBE3(std::vector<std::string> & records, long & ID, long & PID, std::vector<long> & connectivity, std::string & components);
    bool isInteger(std::string & str);
 
    bool isEnabled(NastranElementType type);
 
protected:
    void enable(NastranElementType type);
    void disable(NastranElementType type);
 
 
    template<class Type>
    void writeValue (Type& value, std::ofstream& os){
 
        std::size_t offset = 5;
        if (m_wformat == WFORMAT::Long) offset = 13;
 
        std::stringstream manip;
        manip <<std::fixed<<std::setprecision(offset+3);
        manip<<value;
        std::string manips = manip.str();
        std::string mantissa, expon;
        std::size_t pos = manips.find("E");
        if (pos < manips.size()){
            mantissa = manips.substr(0,std::min(offset,pos));
            expon = manips.substr(pos+1,manips.size());
            manips = mantissa + expon;
        }
        pos = manips.find("e");
        if (pos < manips.size()){
            mantissa = manips.substr(0,std::min(offset,pos));
            expon = manips.substr(pos+1,manips.size());
            manips = mantissa + expon;
        }
        manips = manips.substr(0, offset+3);
 
        switch (m_wformat)
        {
        case Short:
        {
            os << std::setw(8) << manips;
            break;
        }
        case Long:
        {
            os << std::setw(16) << manips;
            break;
        }
        }
    }
};
 
REGISTER_PORT(M_GEOM, MC_SCALAR, MD_MIMMO_, __MIMMOGEOMETRY_HPP__)
REGISTER(BaseManipulation, MimmoGeometry, "mimmo.Geometry")
 
};
 
#endif /* __MIMMOGEOMETRY_HPP__ */