MRBF.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 __MRBF_HPP__
#define __MRBF_HPP__
 
#include "BaseManipulation.hpp"
#include <bitpit_RBF.hpp>
 
namespace mimmo{
 
enum class MRBFBasisFunction {
    HEAVISIDE10    = 101,  
    HEAVISIDE50    = 102,  
    HEAVISIDE100    = 103,  
    HEAVISIDE1000    = 104,  
    DSIGMOID    = 105,  
};
 
enum class MRBFSol{
    NONE = 0,     
    WHOLE = 1,    
    GREEDY= 2   
};
 
class MRBF: public BaseManipulation, public bitpit::RBF {
 
protected:
    double       m_tol;          
    MRBFSol      m_solver;       
    dmpvector1D  m_filter;       
    bool         m_bfilter;      
    double       m_supportRadiusValue; 
    bool         m_srIsReal;  
    dvector1D    m_supportRadii; 
    double       m_diagonalFactor; 
    int          m_functype;     
    dmpvecarr3E  m_displ;        
    dmpvector1D  m_scalarDispl;  
    dvector1D    m_effectiveSR; 
    bool         m_isCompact;   
    MimmoSharedPointer<MimmoObject> m_rbfgeometry; 
    dmpvecarr3E* m_rbfdispl;         
    dmpvector1D* m_rbfScalarDispl;  
    dmpvector1D* m_rbfSupportRadii;  
    bool         m_areScalarResults;  
public:
    MRBF(MRBFSol mode = MRBFSol::NONE);
    MRBF(const bitpit::Config::Section & rootXML);
 
    virtual ~MRBF();
 
    //copy operators/constructors
    MRBF(const MRBF & other);
    MRBF& operator=(MRBF other);
 
    void buildPorts();
 
    dvecarr3E*      getNodes();
 
    MRBFSol         getMode();
    dmpvector1D*    getFilter();
 
    bool            isSupportRadiusReal();
    bool            isVariableSupportRadiusSet();
    dvector1D &     getEffectivelyUsedSupportRadii();
    double          getDiagonalFactor();
 
    int             getFunctionType();
    dmpvecarr3E*    getDisplacements();
    dmpvector1D*    getScalarDisplacements();
 
    bool            isCompact();
    bool            areResultsInScalarMode();
 
    int             addNode(darray3E);
    ivector1D       addNode(dvecarr3E);
 
    void            setNode(darray3E);
    void            setNode(dvecarr3E);
    void            setNode(MimmoSharedPointer<MimmoObject> geometry);
    void            setFilter(dmpvector1D * );
 
    ivector1D       checkDuplicatedNodes(double tol=1.0E-12);
    bool            removeDuplicatedNodes(ivector1D * list=nullptr);
 
    void            setSupportRadiusLocal(double suppR_);
    void            setSupportRadiusReal(double suppR_);
    void            setVariableSupportRadii(dvector1D sradii);
    void            setVariableSupportRadii(dmpvector1D* sradii);
    void            setDiagonalFactor(double diagonalFactor);
 
BITPIT_DEPRECATED(
    void            setSupportRadiusValue(double suppR_));
 
    void            setTol(double tol);
    void            setDisplacements(dvecarr3E displ);
    void            setDisplacements(dmpvecarr3E* displ);
    void            setScalarDisplacements(dvector1D displ);
    void            setScalarDisplacements(dmpvector1D* displ);
 
    void            setFunction(const MRBFBasisFunction & funct, bool isCompact = false);
    void            setFunction(const bitpit::RBFBasisFunction & funct, bool isCompact = false);
    void            setCompactSupport(bool isCompact = true);
 
    void            clear();
    void            clearFilter();
 
    void            execute();
    void            apply();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="");
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="");
 
protected:
    void            swap(MRBF & x) noexcept;
    void            checkFilter();
    void            setWeight(dvector2D value);
    void            plotCloud(std::string directory, std::string filename, int counterFile, bool binary, bool deformed);
    virtual void    plotOptionalResults();
 
    void            computeEffectiveSupportRadiusList();
 
    bool             initRBFwGeometry();
 
    //reimplemented from RBFKernel
    void            setMode(MRBFSol solver);
    std::vector<double> evalRBF(const std::array<double,3> & val);
 
private:
 
    // redeclared to be private in the current class:
    // they behave exactly as in the base class but they are not accessible in MRBF.
 
    void  setSupportRadius(double val){bitpit::RBFKernel::setSupportRadius(val);};
    double getSupportRadius(){return bitpit::RBFKernel::getSupportRadius();};
    void  setMode(bitpit::RBFMode mode){bitpit::RBFKernel::setMode(mode);};
 
    void  setDataToNode (int n, const std::vector<double> &data){bitpit::RBFKernel::setDataToNode(n,data);};
    void  setDataToAllNodes(int n , const std::vector<double> & data){bitpit::RBFKernel::setDataToAllNodes(n,data);};
 
    int   addData(){return bitpit::RBFKernel::addData();};
    int   addData(const std::vector<double> & data){return bitpit::RBFKernel::addData(data);};
    bool  removeData(int n){return bitpit::RBFKernel::removeData(n);};
    bool  removeData(std::vector<int> &nn){return bitpit::RBFKernel::removeData(nn);};
    void  removeAllData(){bitpit::RBFKernel::removeAllData();};
 
    std::vector<double> evalRBF(int jnode){return bitpit::RBFKernel::evalRBF(jnode);};
 
    int solve(){return bitpit::RBFKernel::solve();};
    int greedy(double tol){return bitpit::RBFKernel::greedy(tol);};
};
 
double  heaviside10( double dist );
double  heaviside50( double dist );
double  heaviside100( double dist );
double  heaviside1000( double dist );
double  dsigmoid( double dist );
 
REGISTER_PORT(M_COORDS, MC_VECARR3, MD_FLOAT ,__MRBF_HPP__)
REGISTER_PORT(M_DISPLS, MC_VECARR3, MD_FLOAT ,__MRBF_HPP__)
REGISTER_PORT(M_DATAFIELD, MC_VECTOR, MD_FLOAT, __MRBF_HPP_)
REGISTER_PORT(M_DATAFIELD2, MC_VECTOR, MD_FLOAT, __MRBF_HPP_)
REGISTER_PORT(M_FILTER, MC_SCALAR, MD_MPVECFLOAT_ ,__MRBF_HPP__)
REGISTER_PORT(M_GEOM, MC_SCALAR, MD_MIMMO_ ,__MRBF_HPP__)
REGISTER_PORT(M_GEOM2, MC_SCALAR, MD_MIMMO_ ,__MRBF_HPP_)
REGISTER_PORT(M_VECTORFIELD, MC_SCALAR, MD_MPVECARR3FLOAT_ ,__MRBF_HPP_)
REGISTER_PORT(M_SCALARFIELD, MC_SCALAR, MD_MPVECFLOAT_ ,__MRBF_HPP_)
REGISTER_PORT(M_SCALARFIELD2, MC_SCALAR, MD_MPVECFLOAT_ ,__MRBF_HPP_)
REGISTER_PORT(M_GDISPLS, MC_SCALAR, MD_MPVECARR3FLOAT_ ,__MRBF_HPP__)
 
REGISTER(BaseManipulation, MRBF, "mimmo.MRBF")
 
};
 
#endif /* __MRBF_HPP__ */