FFDLattice.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 __FFDLATTICE_HPP__
#define __FFDLATTICE_HPP__
 
#include "Lattice.hpp"
 
namespace mimmo{
 
class FFDLattice: public Lattice {
 
protected:
    iarray3E    m_deg;           
    dvector2D    m_knots;        
    ivector2D    m_mapEff;       
    dvector1D    m_weights;      
    dvecarr3E    m_displ;        
    ivector2D     m_mapNodes;    
    dmpvecarr3E    m_gdispl;     
private:
    iarray3E    m_mapdeg;        
    bool        m_globalDispl;   
    std::unordered_map<int, double> m_collect_wg; 
    dmpvector1D   m_filter;      
    bool         m_bfilter;      
public:
    FFDLattice();
    FFDLattice(const bitpit::Config::Section & rootXML);
    virtual ~FFDLattice();
 
    //copy operators/constructors
    FFDLattice(const FFDLattice & other);
    FFDLattice & operator=(FFDLattice other);
 
    void buildPorts();
 
    //clean structure
    void         clearLattice();
    void         clearFilter();
 
    //internal methods
    ivector1D    getKnotsDimension();
    dvector1D    getWeights();
    void         returnKnotsStructure(dvector2D &, ivector2D &);
    void         returnKnotsStructure( int, dvector1D &, ivector1D &);
    dvecarr3E*   getDisplacements();
    dmpvector1D* getFilter();
    dmpvecarr3E* getDeformation();
    bool         isDisplGlobal();
    iarray3E     getDegrees();
 
    void         setDegrees(iarray3E curveDegrees);
    void         setDisplacements(dvecarr3E displacements);
    void         setDisplGlobal(bool flag);
    void         setLattice(darray3E & origin, darray3E & span, ShapeType, iarray3E & dimensions, iarray3E & degrees);
    void         setLattice(darray3E & origin, darray3E & span, ShapeType, dvector1D & spacing, iarray3E & degrees);
    void         setLattice(BasicShape *, iarray3E & dimensions,  iarray3E & degrees);
    void         setLattice(BasicShape *, dvector1D & spacing,iarray3E & degrees);
 
    void         setNodalWeight(double , int );
    void         setNodalWeight(double , int, int, int);
    void         setNodalWeight(dvector1D );
 
    void        setFilter(dmpvector1D * );
 
    //plotting wrappers
    void        plotGrid(std::string directory, std::string filename, int counter, bool binary, bool deformed);
    void        plotCloud(std::string directory, std::string filename, int counter, bool binary, bool deformed);
 
 
    //execute deformation methods
    void         execute();
    darray3E     apply(darray3E & point);
    dvecarr3E    apply(dvecarr3E * point);
    dvecarr3E    apply(livector1D & map);
 
    virtual bool build();
 
    void         apply();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name = "");
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name= "");
 
protected:
    darray3E     convertDisplToXYZ(darray3E &, int i);
    dvecarr3E    convertDisplToXYZ();
    void         resizeMapDof();
    virtual void plotOptionalResults();
    void         swap(FFDLattice &) noexcept;
    void         checkFilter();
 
private:
    //Nurbs Evaluators
    darray3E    nurbsEvaluator(darray3E &);
    dvecarr3E   nurbsEvaluator(livector1D &);
    double      nurbsEvaluatorScalar(darray3E &, int);
 
    //Nurbs utilities
    dvector1D    basisITS0(int k, int pos, double coord);
    dvector1D    getNodeSpacing(int dir);
 
    //knots mantenaince utilities
    void         clearKnots();
    void         setKnotsStructure();
    void         setKnotsStructure(int dir, CoordType type);
    int          getKnotInterval(double, int);
    double       getKnotValue(int, int);
    int          getKnotIndex(int,int);
    int          getTheoreticalKnotIndex(int,int);
 
    //nodal displacement utility
    dvecarr3E    recoverFullGridDispl();
    dvector1D    recoverFullNodeWeights();
    void         setMapNodes(int ind);
    int          accessMapNodes(int,int,int);
 
 
    //dimension utilities
    void         orderDimension();
};
 
inline int FFDLattice::accessMapNodes(int i, int j, int k){
    return(accessPointIndex(m_mapNodes[0][i], m_mapNodes[1][j], m_mapNodes[2][k]));
};
 
REGISTER_PORT(M_DISPLS, MC_VECARR3, MD_FLOAT,__FFDLATTICE_HPP__)
REGISTER_PORT(M_FILTER, MC_SCALAR, MD_MPVECFLOAT_,__FFDLATTICE_HPP__)
REGISTER_PORT(M_DEG, MC_ARRAY3, MD_INT,__FFDLATTICE_HPP__)
REGISTER_PORT(M_NURBSWEIGHTS, MC_VECTOR, MD_FLOAT,__FFDLATTICE_HPP__)
REGISTER_PORT(M_NURBSCOORDTYPE, MC_ARRAY3, MD_COORDT,__FFDLATTICE_HPP__)
REGISTER_PORT(M_GDISPLS, MC_SCALAR, MD_MPVECARR3FLOAT_,__FFDLATTICE_HPP__)
 
REGISTER(BaseManipulation, FFDLattice, "mimmo.FFDLattice")
}
 
#endif /* __FFDLATTICE_HPP__ */