SelectField.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 __SelectFieldS_HPP__
#define __SelectFieldS_HPP__
 
#include "BaseManipulation.hpp"
 
namespace mimmo{
 
enum class SelectType{
            GEOMETRY = 0, 
            NAME = 1, 
            MAPPING = 2 
};
 
class SelectField: public BaseManipulation{
protected:
    SelectType m_mode; 
    double m_tol;  
    std::string m_fieldname; 
public:
    SelectField();
    virtual ~SelectField();
 
    SelectField(const SelectField & other);
 
    void buildPorts();
 
    void        setMode(SelectType mode);
    void        setMode(int mode);
    void        setFieldName(std::string fieldname);
    void        setTolerance(double tol);
 
    std::string getFieldName();
 
    void         clear();
    void         execute();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="");
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="");
 
protected:
    void swap(SelectField &) noexcept;
private:
    virtual bool mSelect() = 0;
};
 
class SelectScalarField: public SelectField{
private:
    MPVLocation m_loc;  
    std::vector<dmpvector1D> m_fields;   
    dmpvector1D m_result;               
public:
    SelectScalarField(MPVLocation loc = MPVLocation::POINT);
    SelectScalarField(const bitpit::Config::Section & rootXMl);
    SelectScalarField(const SelectScalarField & other);
    virtual ~SelectScalarField();
 
    void buildPorts();
    dmpvector1D*     getSelectedField();
    void     setFields(std::vector<dmpvector1D *> fields);
    void     addField(dmpvector1D *field);
 
    void clear();
 
    void     plotOptionalResults();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="");
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="");
 
protected:
    void swap(SelectScalarField &) noexcept;
 
private:
    bool mSelect();
 
};
 
 
 
class SelectVectorField: public SelectField{
private:
    MPVLocation m_loc;  
    std::vector<dmpvecarr3E>  m_fields;   
    dmpvecarr3E m_result;                
public:
 
    SelectVectorField(MPVLocation loc = MPVLocation::POINT);
    SelectVectorField(const bitpit::Config::Section & rootXMl);
    SelectVectorField(const SelectVectorField & other);
    virtual ~SelectVectorField();
 
    void buildPorts();
    dmpvecarr3E*     getSelectedField();
    void     setFields(std::vector<dmpvecarr3E *> fields);
    void     addField(dmpvecarr3E *field);
 
    void clear();
 
    void     plotOptionalResults();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="");
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="");
 
protected:
    void swap(SelectVectorField &) noexcept;
 
private:
    bool mSelect();
 
};
 
 
 
class SelectLongField: public SelectField{
private:
    MPVLocation                             m_loc;      
    std::vector<MimmoPiercedVector<long> >  m_fields;   
    MimmoPiercedVector<long>                m_result;   
public:
 
    SelectLongField(MPVLocation loc = MPVLocation::POINT);
    SelectLongField(const bitpit::Config::Section & rootXMl);
    SelectLongField(const SelectLongField & other);
    virtual ~SelectLongField();
 
    void buildPorts();
    MimmoPiercedVector<long>*     getSelectedField();
    void     setFields(std::vector<MimmoPiercedVector<long> *> fields);
    void     addField(MimmoPiercedVector<long> *field);
 
    void clear();
 
    void     plotOptionalResults();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="");
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="");
 
protected:
    void swap(SelectLongField &) noexcept;
 
private:
    bool mSelect();
 
};
 
 
 
class SelectStringField: public SelectField{
private:
    MPVLocation                                     m_loc;      
    std::vector<MimmoPiercedVector<std::string>>    m_fields;   
    MimmoPiercedVector<std::string>                 m_result;   
public:
 
    SelectStringField(MPVLocation loc = MPVLocation::POINT);
    SelectStringField(const bitpit::Config::Section & rootXMl);
    SelectStringField(const SelectStringField & other);
    virtual ~SelectStringField();
 
    void buildPorts();
    MimmoPiercedVector<std::string>*     getSelectedField();
    void     setFields(std::vector<MimmoPiercedVector<std::string> *> fields);
    void     addField(MimmoPiercedVector<std::string> *field);
 
    void clear();
 
    void     plotOptionalResults();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name="");
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name="");
 
protected:
    void swap(SelectStringField &) noexcept;
 
private:
    bool mSelect();
 
};
 
 
 
REGISTER_PORT(M_GEOM, MC_SCALAR, MD_MIMMO_, __SelectFieldS_HPP__)
REGISTER_PORT(M_NAME, MC_SCALAR, MD_STRING, __SelectFieldS_HPP__)
REGISTER_PORT(M_SCALARFIELD, MC_SCALAR, MD_MPVECFLOAT_, __SelectFieldS_HPP__)
REGISTER_PORT(M_VECTORFIELD, MC_SCALAR, MD_MPVECARR3FLOAT_, __SelectFieldS_HPP__)
REGISTER_PORT(M_LONGFIELD, MC_SCALAR, MD_MPVECLONG_, __SelectFieldS_HPP__)
REGISTER_PORT(M_STRINGFIELD, MC_SCALAR, MD_MPVECSTRING_, __SelectFieldS_HPP__)
REGISTER_PORT(M_VECSCALARFIELDS, MC_VECTOR, MD_MPVECFLOAT_, __SelectFieldS_HPP__)
REGISTER_PORT(M_VECVECTORFIELDS, MC_VECTOR, MD_MPVECARR3FLOAT_, __SelectFieldS_HPP__)
REGISTER_PORT(M_VECLONGFIELDS, MC_VECTOR, MD_MPVECLONG_, __SelectFieldS_HPP__)
REGISTER_PORT(M_VECSTRINGFIELDS, MC_VECTOR, MD_MPVECSTRING_, __SelectFieldS_HPP__)
 
REGISTER(BaseManipulation, SelectScalarField, "mimmo.SelectScalarField")
REGISTER(BaseManipulation, SelectVectorField, "mimmo.SelectVectorField")
REGISTER(BaseManipulation, SelectLongField, "mimmo.SelectLongField")
REGISTER(BaseManipulation, SelectStringField, "mimmo.SelectStringField")
};
 
#endif /* __SelectFieldS_HPP__ */