CreateSeedsOnSurface.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 __CREATESEEDSONSURFACE_HPP__
#define __CREATESEEDSONSURFACE_HPP__
 
#include "BaseManipulation.hpp"
#include "OBBox.hpp"
 
 
 
namespace mimmo{
 
enum class CSeedSurf{
    RANDOM = 0 ,
    LEVELSET = 1 ,
    CARTESIANGRID=2 
};
 
class CreateSeedsOnSurface: public mimmo::BaseManipulation {
 
private:
 
    dvecarr3E   m_points;         
    int         m_nPoints;        
    double      m_minDist;        
    darray3E    m_seed;           
    CSeedSurf   m_engine;         
    bool        m_seedbaricenter; 
    bool        m_randomFixed;    
    uint32_t    m_randomSignature;
    dmpvector1D m_sensitivity;    
    //utility members
    std::unique_ptr<mimmo::OBBox> m_bbox;     
    livector1D m_deads;                     
    dmpvector1D m_sensitivity_triangulated; 
    dvector1D m_final_sensitivity;          
public:
    CreateSeedsOnSurface();
    CreateSeedsOnSurface(const bitpit::Config::Section & rootXML);
    virtual ~CreateSeedsOnSurface();
    CreateSeedsOnSurface(const CreateSeedsOnSurface & other);
    CreateSeedsOnSurface & operator=(CreateSeedsOnSurface other);
 
    void    buildPorts();
 
    //get methods
    int          getNPoints();
    dvecarr3E    getPoints();
    CSeedSurf    getEngineENUM();
    int          getEngine();
    darray3E     getSeed();
    bool         isSeedMassCenter();
    double       getMinDistance();
    bool         isRandomFixed();
    long         getRandomSignature();
 
    //set methods
    void         setNPoints( int);
    void         setEngineENUM( CSeedSurf);
    void         setEngine(int);
    void         setSeed(darray3E);
    void         setMassCenterAsSeed(bool );
    void         setGeometry(MimmoSharedPointer<MimmoObject>);
    void         setRandomFixed(bool fix);
    void         setRandomSignature(uint32_t signature);
    void         setSensitivityMap(dmpvector1D *field);
 
    void         clear();
 
    void         solve(bool debug = false);
    void         plotCloud(std::string dir, std::string file, int counter, bool binary);
 
    void         execute();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="");
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="");
 
protected:
    virtual void plotOptionalResults();
    void    swap(CreateSeedsOnSurface & x) noexcept;
    void    checkField();
    void    normalizeField();
    bool    checkTriangulation();
    MimmoSharedPointer<MimmoObject> createTriangulation();
 
private:
    void    solveLSet( bool debug = false);
    void    solveGrid(bool debug = false);
    void    solveRandom(bool debug = false);
 
    void decimatePoints(dvecarr3E & rawpoint, dvector1D & rawsensi);
 
    void   solveEikonal(double g, double s, bitpit::PatchKernel &tri,std::unordered_map<long,long> & invConn, dmpvector1D & field);
    double updateEikonal(double g, double s, long tVert,long tCell,bitpit::PatchKernel &tri, std::unordered_map<long int, short int> &flag, dmpvector1D & field);
 
    std::unordered_map<long,long>    getInverseConn(bitpit::PatchKernel &);
    bool                             isDeadFront(const long int label);
    std::set<long>    findVertexVertexOneRing(bitpit::PatchKernel &, const long &, const long & );
};
 
REGISTER_PORT(M_POINT, MC_ARRAY3, MD_FLOAT,__CREATESEEDSONSURFACE_HPP__)
REGISTER_PORT(M_VALUELI, MC_SCALAR, MD_LONG,__CREATESEEDSONSURFACE_HPP__)
REGISTER_PORT(M_GEOM, MC_SCALAR, MD_MIMMO_,__CREATESEEDSONSURFACE_HPP__)
REGISTER_PORT(M_FILTER, MC_SCALAR, MD_MPVECFLOAT_,__CREATESEEDSONSURFACE_HPP__)
REGISTER_PORT(M_COORDS, MC_VECARR3, MD_FLOAT,__CREATESEEDSONSURFACE_HPP__)
 
 
REGISTER(BaseManipulation, CreateSeedsOnSurface, "mimmo.CreateSeedsOnSurface")
};
 
#endif /* __CREATESEEDSONSURFACE_HPP__ */