FVMeshSelection.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 __FVMESHSELECTION_HPP__
#define __FVMESHSELECTION_HPP__
 
#include <BaseManipulation.hpp>
#include <MeshSelection.hpp>
 
namespace mimmo{
 
class FVGenericSelection: public mimmo::BaseManipulation {
 
public:
    FVGenericSelection(int topo = 1);
    virtual ~FVGenericSelection();
    FVGenericSelection(const FVGenericSelection & other);
    FVGenericSelection & operator=(FVGenericSelection other);
 
    void               setGeometry(mimmo::MimmoSharedPointer<MimmoObject>);
    void               setBoundaryGeometry(mimmo::MimmoSharedPointer<MimmoObject>);
    void               setDual(bool flag=false);
    void               setSelection(MimmoSharedPointer<GenericSelection> selectBlock);
 
    const mimmo::MimmoSharedPointer<MimmoObject>    getVolumePatch()const;
    const mimmo::MimmoSharedPointer<MimmoObject>    getBoundaryPatch()const;
    const mimmo::MimmoSharedPointer<MimmoObject>    getInternalBoundaryPatch()const;
 
    mimmo::MimmoSharedPointer<MimmoObject>          getVolumePatch();
    mimmo::MimmoSharedPointer<MimmoObject>          getBoundaryPatch();
    mimmo::MimmoSharedPointer<MimmoObject>          getInternalBoundaryPatch();
 
    bool    isDual();
    void    execute();
 
 
protected:
    void swap(FVGenericSelection &x) noexcept;
    void    buildPorts();
    virtual void plotOptionalResults();
    bool checkCoherenceBulkBoundary();
    void cleanUpBoundaryPatch();
    MimmoSharedPointer<MimmoObject> createInternalBoundaryPatch();
 
    int                             m_topo;      
    bool                            m_dual;      
    MimmoSharedPointer<MimmoObject>    m_bndgeometry; 
    MimmoSharedPointer<GenericSelection> m_selectEngine; 
    MimmoSharedPointer<MimmoObject>    m_volpatch;  
    MimmoSharedPointer<MimmoObject>    m_bndpatch;  
    MimmoSharedPointer<MimmoObject>    m_intbndpatch;  
private:
    //interface blocked method.
    MimmoSharedPointer<MimmoObject> getGeometry(){return nullptr;};
 
};
 
 
class FVSelectionByBox: public FVGenericSelection {
 
public:
    FVSelectionByBox(int topo = 1);
    FVSelectionByBox(const bitpit::Config::Section & rootXML);
    FVSelectionByBox(int topo, darray3E origin, darray3E span);
    virtual ~FVSelectionByBox();
    FVSelectionByBox(const FVSelectionByBox & other);
    FVSelectionByBox & operator=(FVSelectionByBox other);
 
    void setOrigin(darray3E origin);
    void setSpan(darray3E span);
    void setRefSystem(dmatrix33E axes);
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="" );
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="" );
 
protected:
    void swap(FVSelectionByBox &) noexcept;
    void buildPorts();
 
private:
   void  setSelection(MimmoSharedPointer<GenericSelection> selectBlock){BITPIT_UNUSED(selectBlock);};
};
 
class FVSelectionByCylinder: public FVGenericSelection{
 
public:
    FVSelectionByCylinder(int topo = 1);
    FVSelectionByCylinder(const bitpit::Config::Section & rootXML);
    FVSelectionByCylinder(int topo, darray3E origin, darray3E span, double infLimTheta, darray3E mainAxis);
    virtual ~FVSelectionByCylinder();
    FVSelectionByCylinder(const FVSelectionByCylinder & other);
    FVSelectionByCylinder & operator=(FVSelectionByCylinder other);
 
    void setOrigin(darray3E origin);
    void setSpan(darray3E span);
    void setRefSystem(dmatrix33E axes);
    void setInfLimits(darray3E val);
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="" );
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="" );
 
protected:
    void swap(FVSelectionByCylinder &) noexcept;
    void buildPorts();
 
private:
    void  setSelection(MimmoSharedPointer<GenericSelection> selectBlock){BITPIT_UNUSED(selectBlock);};
 
};
 
 
class FVSelectionBySphere: public FVGenericSelection {
 
public:
    FVSelectionBySphere(int topo = 1);
    FVSelectionBySphere(const bitpit::Config::Section & rootXML);
    FVSelectionBySphere(int topo, darray3E origin, darray3E span, double infLimTheta, double infLimPhi);
    virtual ~FVSelectionBySphere();
    FVSelectionBySphere(const FVSelectionBySphere & other);
    FVSelectionBySphere & operator=(FVSelectionBySphere other);
 
    void setOrigin(darray3E origin);
    void setSpan(darray3E span);
    void setRefSystem(dmatrix33E axes);
    void setInfLimits(darray3E val);
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="" );
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="" );
 
protected:
    void swap(FVSelectionBySphere &) noexcept;
    void buildPorts();
 
private:
    void  setSelection(MimmoSharedPointer<GenericSelection> selectBlock){BITPIT_UNUSED(selectBlock);};
 
};
 
 
REGISTER_PORT(M_GEOM, MC_SCALAR, MD_MIMMO_, __FVMESHSELECTION_HPP__)
REGISTER_PORT(M_GEOM2, MC_SCALAR, MD_MIMMO_, __FVMESHSELECTION_HPP__)
REGISTER_PORT(M_GEOM3, MC_SCALAR, MD_MIMMO_, __FVMESHSELECTION_HPP__)
REGISTER_PORT(M_POINT, MC_ARRAY3, MD_FLOAT, __FVMESHSELECTION_HPP__)
REGISTER_PORT(M_AXES, MC_ARR3ARR3, MD_FLOAT, __FVMESHSELECTION_HPP__)
REGISTER_PORT(M_SPAN, MC_ARRAY3, MD_FLOAT, __FVMESHSELECTION_HPP__)
REGISTER_PORT(M_INFLIMITS, MC_ARRAY3, MD_FLOAT, __FVMESHSELECTION_HPP__)
 
 
REGISTER(BaseManipulation, FVSelectionByBox,"mimmo.FVSelectionByBox")
REGISTER(BaseManipulation, FVSelectionByCylinder, "mimmo.FVSelectionByCylinder")
REGISTER(BaseManipulation, FVSelectionBySphere,"mimmo.FVSelectionBySphere")
};
 
 
#endif /* __FVMESHSELECTION_HPP__ */