GenericInput.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 __INPUTDOF_HPP__
#define __INPUTDOF_HPP__
 
#include "BaseManipulation.hpp"
#include "IOData.hpp"
 
namespace mimmo{
 
namespace inputCSVStream{
    template<typename T>
    std::fstream&  ifstreamcsv(std::fstream &in, T &x);
    template<typename T>
    std::fstream&  ifstreamcsvend(std::fstream &in, T &x);
    template<typename T>
    std::fstream&  ifstreamcsv(std::fstream &in, std::vector< T > &x);
    template<typename T, size_t d>
    std::fstream&  ifstreamcsv(std::fstream &in, std::array< T,d > &x);
    template<typename T>
    std::fstream&  ifstreamcsvend(std::fstream &in, std::vector< T > &x);
    template<typename T, size_t d>
    std::fstream&  ifstreamcsvend(std::fstream &in, std::array< T,d > &x);
    template<typename T>
    std::fstream&  ifstreamcsv(std::fstream &in, MimmoPiercedVector< T > &x);
    template<typename T, size_t d>
    std::fstream&  ifstreamcsv(std::fstream &in, MimmoPiercedVector< std::array< T,d > > &x);
 
}
 
class GenericInput: public BaseManipulation{
 
private:
    bool            m_readFromFile; 
    bool            m_csv;          
    std::string     m_dir;          
    std::string     m_filename;     
    std::unique_ptr<IOData>                m_input;        
    std::unique_ptr<IOData>                m_result;        
public:
    GenericInput(bool readFromFile = false, bool csv = false);
    GenericInput(const bitpit::Config::Section & rootXML);
    GenericInput(std::string dir, std::string filename, bool csv = false);
 
    BITPIT_DEPRECATED( template<typename T>
    GenericInput(T data){
        setInput<T>(data);
    });
    ~GenericInput();
 
    GenericInput(const GenericInput & other);
    GenericInput & operator=(GenericInput other);
 
    void buildPorts();
 
    BITPIT_DEPRECATED( template<typename T> T* getInput());
 
    template<typename T>
    T  getResult();
 
    void setReadFromFile(bool readFromFile);
    void setCSV(bool csv);
    void setReadDir(std::string dir);
    void setFilename(std::string filename);
 
    template<typename T>
    void                 setInput(T* data);
    template<typename T>
    void                 setInput(T& data);
 
    BITPIT_DEPRECATED( template<typename T>
    void                 setResult(T* data));
    BITPIT_DEPRECATED( template<typename T>
    void                 setResult(T& data));
 
    void    clearInput();
    void    clearResult();
 
    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(GenericInput & x) noexcept;
#if MIMMO_ENABLE_MPI
    template<typename T>
    void                sendReadDataToAllProcs(T & data);
#endif
 
private:
 
    template<typename T>
    void                 _setInput(T* data);
    template<typename T>
    void                 _setInput(T& data);
 
    template<typename T>
    void                 _setResult(T* data);
    template<typename T>
    void                 _setResult(T& data);
 
    template<typename T>
    T*                    _getInput();
 
    template<typename T>
    T*                    _getResult();
 
};
 
class GenericInputMPVData: public BaseManipulation{
private:
    bool            m_csv;          
    std::string     m_dir;          
    std::string     m_filename;     
    std::unique_ptr<IOData>                m_result;        
    bool            m_binary;       
public:
    GenericInputMPVData(bool csv = false);
    GenericInputMPVData(const bitpit::Config::Section & rootXML);
    GenericInputMPVData(std::string dir, std::string filename, bool csv = false);
 
    ~GenericInputMPVData();
 
    GenericInputMPVData(const GenericInputMPVData & other);
    GenericInputMPVData & operator=(GenericInputMPVData other);
 
    void buildPorts();
 
    template<typename T>
    MimmoPiercedVector<T>  * getResult();
 
 
    void setCSV(bool csv);
    void setReadDir(std::string dir);
    void setFilename(std::string filename);
    void setBinary(bool binary);
 
    void    clearResult();
 
    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(GenericInputMPVData & x) noexcept;
#if MIMMO_ENABLE_MPI
    template<typename T>
    void sendReadDataToAllProcs(MimmoPiercedVector<T> & data);
#endif
 
private:
 
    template<typename T>
    MimmoPiercedVector< T >*         _getResult();
    template<typename T>
    void                             _setResult(MimmoPiercedVector< T >*);
    template<typename T>
    void                             _setResult(MimmoPiercedVector< T >&);
 
 
};
 
REGISTER_PORT(M_COORDS, MC_VECARR3, MD_FLOAT,__INPUTDOF_HPP__)
REGISTER_PORT(M_DISPLS, MC_VECARR3, MD_FLOAT,__INPUTDOF_HPP__)
REGISTER_PORT(M_DATAFIELD, MC_VECTOR, MD_FLOAT,__INPUTDOF_HPP__)
REGISTER_PORT(M_POINT, MC_ARRAY3, MD_FLOAT,__INPUTDOF_HPP__)
REGISTER_PORT(M_SPAN, MC_ARRAY3, MD_FLOAT,__INPUTDOF_HPP__)
REGISTER_PORT(M_DIMENSION, MC_ARRAY3, MD_INT,__INPUTDOF_HPP__)
REGISTER_PORT(M_VALUED, MC_SCALAR, MD_FLOAT,__INPUTDOF_HPP__)
REGISTER_PORT(M_VALUEI, MC_SCALAR, MD_INT,__INPUTDOF_HPP__)
REGISTER_PORT(M_VALUEB, MC_SCALAR, MD_BOOL,__INPUTDOF_HPP__)
REGISTER_PORT(M_DEG, MC_ARRAY3, MD_INT,__INPUTDOF_HPP__)
REGISTER_PORT(M_VECTORFIELD, MC_SCALAR, MD_MPVECARR3FLOAT_,__INPUTDOF_HPP__)
REGISTER_PORT(M_SCALARFIELD, MC_SCALAR, MD_MPVECFLOAT_,__INPUTDOF_HPP__)
REGISTER_PORT(M_GEOM, MC_SCALAR, MD_MIMMO_ ,__INPUTDOF_HPP__)
 
REGISTER(BaseManipulation, GenericInput, "mimmo.GenericInput")
REGISTER(BaseManipulation, GenericInputMPVData, "mimmo.GenericInputMPVData")
 
}
 
#include "GenericInput.tpp"
 
#endif /* __INPUTDOF_HPP__ */