ExtractFields.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 __EXTRACTFIELDS_HPP__
#define __EXTRACTFIELDS_HPP__
 
#include "BaseManipulation.hpp"
 
namespace mimmo{
enum class ExtractMode{
    ID = 1, 
    PID = 2, 
    MAPPING = 3 
};
 
class ExtractField: public BaseManipulation{
protected:
    ExtractMode m_mode; 
    double      m_tol;  
public:
    ExtractField();
    virtual ~ExtractField();
 
    ExtractField(const ExtractField & other);
    ExtractField& operator=(const ExtractField & other);
 
    void buildPorts();
 
    void        setMode(ExtractMode mode);
    void        setMode(int mode);
    void        setTolerance(double tol);
    using BaseManipulation::setGeometry;
 
    ExtractMode getMode();
    double      getTolerance();
 
    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="");
 
    virtual bool extract() = 0;
 
protected:
    void swap(ExtractField & x) noexcept;
 
};
 
 
class ExtractScalarField: public ExtractField{
private:
    dmpvector1D m_field;             
    dmpvector1D m_result;               
public:
    ExtractScalarField();
    ExtractScalarField(const bitpit::Config::Section & rootXMl);
    virtual ~ExtractScalarField();
 
    ExtractScalarField(const ExtractScalarField & other);
    ExtractScalarField& operator=(const ExtractScalarField & other);
 
    void buildPorts();
    dmpvector1D* getExtractedField();
    void     setField(dmpvector1D *field);
 
    dmpvector1D getOriginalField();
 
    void clear();
 
    void     plotOptionalResults();
    bool     extract();
 
protected:
    void swap(ExtractScalarField & x) noexcept;
 
private:
 
    void extractID(mimmo::MPVLocation loc);
    void extractPID(mimmo::MPVLocation loc);
    void extractMapping(mimmo::MPVLocation loc);
 
};
 
 
class ExtractVectorField: public ExtractField{
private:
    dmpvecarr3E m_field;         
    dmpvecarr3E m_result;        
public:
 
    ExtractVectorField();
    ExtractVectorField(const bitpit::Config::Section & rootXMl);
    virtual ~ExtractVectorField();
    ExtractVectorField(const ExtractVectorField & other);
    ExtractVectorField& operator=(const ExtractVectorField & other);
 
    void buildPorts();
    dmpvecarr3E  *   getExtractedField();
    void     setField(dmpvecarr3E*field);
 
    dmpvecarr3E     getOriginalField();
    void clear();
 
    void     plotOptionalResults();
    bool     extract();
 
protected:
    void swap(ExtractVectorField & x) noexcept;
 
private:
    void extractID(mimmo::MPVLocation loc);
    void extractPID(mimmo::MPVLocation loc);
    void extractMapping(mimmo::MPVLocation loc);
 
};
 
 
class ExtractLongField: public ExtractField{
private:
    MimmoPiercedVector<long> m_field;             
    MimmoPiercedVector<long> m_result;               
public:
    ExtractLongField();
    ExtractLongField(const bitpit::Config::Section & rootXMl);
    virtual ~ExtractLongField();
 
    ExtractLongField(const ExtractLongField & other);
    ExtractLongField& operator=(const ExtractLongField & other);
 
    void buildPorts();
    MimmoPiercedVector<long>* getExtractedField();
    void     setField(MimmoPiercedVector<long> *field);
 
    MimmoPiercedVector<long> getOriginalField();
 
    void clear();
 
    void     plotOptionalResults();
    bool     extract();
 
protected:
    void swap(ExtractLongField & x) noexcept;
 
private:
 
    void extractID(mimmo::MPVLocation loc);
    void extractPID(mimmo::MPVLocation loc);
    void extractMapping(mimmo::MPVLocation loc);
 
};
 
 
 
class ExtractStringField: public ExtractField{
private:
    MimmoPiercedVector<std::string> m_field;             
    MimmoPiercedVector<std::string> m_result;               
public:
    ExtractStringField();
    ExtractStringField(const bitpit::Config::Section & rootXMl);
    virtual ~ExtractStringField();
 
    ExtractStringField(const ExtractStringField & other);
    ExtractStringField& operator=(const ExtractStringField & other);
 
    void buildPorts();
    MimmoPiercedVector<std::string>* getExtractedField();
    void     setField(MimmoPiercedVector<std::string> *field);
 
    MimmoPiercedVector<std::string> getOriginalField();
 
    void clear();
 
    void     plotOptionalResults();
    bool     extract();
 
protected:
    void swap(ExtractStringField & x) noexcept;
 
private:
 
    void extractID(mimmo::MPVLocation loc);
    void extractPID(mimmo::MPVLocation loc);
    void extractMapping(mimmo::MPVLocation loc);
 
};
 
 
REGISTER_PORT(M_GEOM, MC_SCALAR, MD_MIMMO_, __EXTRACTFIELDS_HPP__)
REGISTER_PORT(M_SCALARFIELD, MC_SCALAR, MD_MPVECFLOAT_,__EXTRACTFIELDS_HPP__)
REGISTER_PORT(M_VECTORFIELD, MC_SCALAR, MD_MPVECARR3FLOAT_,__EXTRACTFIELDS_HPP__)
REGISTER_PORT(M_LONGFIELD, MC_SCALAR, MD_MPVECLONG_,__EXTRACTFIELDS_HPP__)
REGISTER_PORT(M_STRINGFIELD, MC_SCALAR, MD_MPVECSTRING_,__EXTRACTFIELDS_HPP__)
 
REGISTER(BaseManipulation, ExtractScalarField, "mimmo.ExtractScalarField")
REGISTER(BaseManipulation, ExtractVectorField, "mimmo.ExtractVectorField")
REGISTER(BaseManipulation, ExtractLongField, "mimmo.ExtractLongField")
REGISTER(BaseManipulation, ExtractStringField, "mimmo.ExtractStringField")
};
 
#endif /* __EXTRACTFIELDS_HPP__ */