MeshSelection.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 __MESHSELECTION_HPP__
#define __MESHSELECTION_HPP__
 
#include <BaseManipulation.hpp>
#include <BasicShapes.hpp>
 
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <utility>
 
namespace mimmo{
 
enum class SelectionType{
    UNDEFINED    = 0, 
    BOX          = 1, 
    CYLINDER     = 2, 
    SPHERE       = 3, 
    MAPPING      = 4, 
    PID          = 5, 
    BOXwSCALAR   = 11 
};
 
class GenericSelection: public mimmo::BaseManipulation {
 
protected:
 
    SelectionType                   m_type;      
    mimmo::MimmoSharedPointer<MimmoObject>    m_subpatch;  
    int                             m_topo;      
    bool                            m_dual;      
public:
 
    GenericSelection();
    virtual ~GenericSelection();
    GenericSelection(const GenericSelection & other);
    GenericSelection & operator=(const GenericSelection & other);
 
    void    buildPorts();
 
    SelectionType    whichMethod();
    virtual void     setGeometry(mimmo::MimmoSharedPointer<MimmoObject>);
    void             setDual(bool flag=false);
 
    const mimmo::MimmoSharedPointer<MimmoObject>  getPatch()const;
    mimmo::MimmoSharedPointer<MimmoObject>        getPatch();
    bool                isDual();
 
    livector1D    constrainedBoundary();
 
    void        execute();
 
    virtual void plotOptionalResults();
 
protected:
    virtual livector1D extractSelection() = 0;
    void swap(GenericSelection &x) noexcept;
};
 
 
class SelectionByBox: public GenericSelection, public mimmo::Cube {
 
public:
    SelectionByBox();
    SelectionByBox(const bitpit::Config::Section & rootXML);
    SelectionByBox(darray3E origin, darray3E span, mimmo::MimmoSharedPointer<MimmoObject> target);
    virtual ~SelectionByBox();
    SelectionByBox(const SelectionByBox & other);
    SelectionByBox & operator=(SelectionByBox other);
 
    void buildPorts();
 
    void clear();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="" );
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="" );
 
protected:
    livector1D extractSelection();
    void swap(SelectionByBox &) noexcept;
};
 
class SelectionByCylinder: public GenericSelection, public mimmo::Cylinder {
 
public:
    SelectionByCylinder();
    SelectionByCylinder(const bitpit::Config::Section & rootXML);
    SelectionByCylinder(darray3E origin, darray3E span, double infLimTheta, darray3E mainAxis, mimmo::MimmoSharedPointer<MimmoObject> target);
    virtual ~SelectionByCylinder();
    SelectionByCylinder(const SelectionByCylinder & other);
    SelectionByCylinder & operator=(SelectionByCylinder other);
 
    void buildPorts();
 
    void clear();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="" );
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="" );
 
protected:
    livector1D extractSelection();
    void swap(SelectionByCylinder &) noexcept;
};
 
class SelectionBySphere: public GenericSelection, public mimmo::Sphere {
 
public:
    SelectionBySphere();
    SelectionBySphere(const bitpit::Config::Section & rootXML);
    SelectionBySphere(darray3E origin, darray3E span, double infLimTheta, double infLimPhi, mimmo::MimmoSharedPointer<MimmoObject> target);
    virtual ~SelectionBySphere();
    SelectionBySphere(const SelectionBySphere & other);
    SelectionBySphere & operator=(SelectionBySphere other);
 
    void buildPorts();
 
    void clear();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="" );
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="" );
 
protected:
    livector1D extractSelection();
    void swap(SelectionBySphere &) noexcept;
};
 
class SelectionByMapping: public GenericSelection {
 
private:
    double                                              m_tolerance;     
    std::unordered_map<std::string, int>                m_geolist;      
    std::unordered_set<mimmo::MimmoSharedPointer<MimmoObject>>    m_mimmolist;    
    std::vector<std::set< int > >                       m_allowedType;  
    std::vector<std::set< int > >                       m_allowedTopology;  
public:
    SelectionByMapping(int topo = 1);
    SelectionByMapping(const bitpit::Config::Section & rootXML);
    SelectionByMapping(std::unordered_map<std::string, int> & geolist, mimmo::MimmoSharedPointer<MimmoObject> target, double tolerance);
    virtual ~SelectionByMapping();
    SelectionByMapping(const SelectionByMapping & other);
    SelectionByMapping & operator=(SelectionByMapping other);
 
    void    buildPorts();
 
    double    getTolerance();
    void     setTolerance(double tol=1.e-8);
 
    void     setGeometry(mimmo::MimmoSharedPointer<MimmoObject> geometry);
 
    const std::unordered_map<std::string, int> &     getFiles() const;
    void    setFiles(std::unordered_map<std::string,int> );
    void    addFile(std::pair<std::string,int> );
    void     removeFile(std::string);
    void     removeFiles();
    void    addMappingGeometry(mimmo::MimmoSharedPointer<MimmoObject> obj);
    void    removeMappingGeometries();
 
    void clear();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="" );
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="" );
 
protected:
    livector1D extractSelection();
    void swap(SelectionByMapping &) noexcept;
 
private:
    livector1D getProximity(std::pair<std::string, int> val);
    livector1D getProximity(mimmo::MimmoSharedPointer<MimmoObject> obj);
    svector1D extractInfo(std::string);
};
 
class SelectionByPID: public GenericSelection {
 
private:
    std::unordered_set<long>       m_setPID;    
    std::unordered_map<long,bool> m_activePID; 
public:
    SelectionByPID();
    SelectionByPID(const bitpit::Config::Section & rootXML);
    SelectionByPID(livector1D & pidlist, mimmo::MimmoSharedPointer<MimmoObject> target);
    virtual ~SelectionByPID();
    SelectionByPID(const SelectionByPID & other);
    SelectionByPID & operator=(SelectionByPID other);
 
    void    buildPorts();
 
    livector1D getPID();
    livector1D    getActivePID(bool active= true);
 
    void     setGeometry(mimmo::MimmoSharedPointer<MimmoObject>);
    void     setPID(long i = -1);
    void     setPID(livector1D);
 
    void     removePID(long i = -1);
    void     removePID(livector1D);
 
    void     syncPIDList();
    void     clear();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="" );
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="" );
 
protected:
    livector1D extractSelection();
    void swap(SelectionByPID &) noexcept;
 
};
 
class SelectionByBoxWithScalar: public SelectionByBox{
protected:
    dmpvector1D     m_field;          
public:
    SelectionByBoxWithScalar();
    SelectionByBoxWithScalar(const bitpit::Config::Section & rootXML);
    SelectionByBoxWithScalar(darray3E origin, darray3E span, mimmo::MimmoSharedPointer<MimmoObject> target);
    virtual ~SelectionByBoxWithScalar();
    SelectionByBoxWithScalar(const SelectionByBoxWithScalar & other);
    SelectionByBoxWithScalar & operator=(SelectionByBoxWithScalar other);
 
    void buildPorts();
 
    void clear();
 
    void        setField(dmpvector1D *);
    dmpvector1D  * getField();
 
    void execute();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="" );
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="" );
 
    void plotOptionalResults();
protected:
    void swap(SelectionByBoxWithScalar &) noexcept;
 
};
 
class SelectionByElementList: public GenericSelection {
 
public:
    SelectionByElementList();
    SelectionByElementList(const bitpit::Config::Section & rootXML);
    virtual ~SelectionByElementList();
 
    void buildPorts();
    void addAnnotatedCellList(MimmoPiercedVector<long> * celldata);
    void addAnnotatedVertexList(MimmoPiercedVector<long> * vertexdata);
    void addRawCellList(std::vector<long> celldata);
    void addRawVertexList(std::vector<long> vertexdata);
 
    void clear();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="" );
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="" );
 
protected:
 
    std::vector<MimmoPiercedVector<long> *> m_annotatedcells; 
    std::vector<MimmoPiercedVector<long> *> m_annotatedvertices;  
    std::vector<std::vector<long>> m_rawcells;  
    std::vector<std::vector<long>> m_rawvertices;  
    livector1D extractSelection();
    void swap(SelectionByElementList &) noexcept;
};
 
 
 
 
 
 
REGISTER_PORT(M_GEOM, MC_SCALAR, MD_MIMMO_, __MESHSELECTION_HPP__)
REGISTER_PORT(M_VALUEB, MC_SCALAR, MD_BOOL, __MESHSELECTION_HPP__)
REGISTER_PORT(M_VECTORLI, MC_VECTOR, MD_LONG, __MESHSELECTION_HPP__)
REGISTER_PORT(M_VECTORLI2, MC_VECTOR, MD_LONG, __MESHSELECTION_HPP__)
REGISTER_PORT(M_VECTORLI3, MC_VECTOR, MD_LONG, __MESHSELECTION_HPP__)
REGISTER_PORT(M_POINT, MC_ARRAY3, MD_FLOAT, __MESHSELECTION_HPP__)
REGISTER_PORT(M_AXES, MC_ARR3ARR3, MD_FLOAT, __MESHSELECTION_HPP__)
REGISTER_PORT(M_SPAN, MC_ARRAY3, MD_FLOAT, __MESHSELECTION_HPP__)
REGISTER_PORT(M_INFLIMITS, MC_ARRAY3, MD_FLOAT, __MESHSELECTION_HPP__)
REGISTER_PORT(M_GEOM2, MC_SCALAR, MD_MIMMO_, __MESHSELECTION_HPP__)
REGISTER_PORT(M_VALUELI, MC_SCALAR, MD_LONG, __MESHSELECTION_HPP__)
REGISTER_PORT(M_SCALARFIELD, MC_SCALAR, MD_MPVECFLOAT_, __MESHSELECTION_HPP__)
REGISTER_PORT(M_LONGFIELD, MC_SCALAR, MD_MPVECLONG_, __MESHSELECTION_HPP__)
REGISTER_PORT(M_LONGFIELD2, MC_SCALAR, MD_MPVECLONG_, __MESHSELECTION_HPP__)
 
 
REGISTER(BaseManipulation, SelectionByBox,"mimmo.SelectionByBox")
REGISTER(BaseManipulation, SelectionByCylinder, "mimmo.SelectionByCylinder")
REGISTER(BaseManipulation, SelectionBySphere,"mimmo.SelectionBySphere")
REGISTER(BaseManipulation, SelectionByMapping, "mimmo.SelectionByMapping")
REGISTER(BaseManipulation, SelectionByPID, "mimmo.SelectionByPID")
REGISTER(BaseManipulation, SelectionByBoxWithScalar, "mimmo.SelectionByBoxWithScalar")
REGISTER(BaseManipulation, SelectionByElementList, "mimmo.SelectionByElementList")
 
};
 
 
#endif /* __MESHSELECTION_HPP__ */