GenericInput.cpp

/*---------------------------------------------------------------------------*\
 *
 *  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/>.
 *
\*---------------------------------------------------------------------------*/
 
#include "GenericInput.hpp"
 
namespace mimmo {
 
 
GenericInput::GenericInput(bool readFromFile, bool csv){
    m_readFromFile  = readFromFile;
    m_csv           = csv;
    m_portsType     = BaseManipulation::ConnectionType::BOTH;
    m_name          = "mimmo.GenericInput";
    m_dir           = "./";
};
 
GenericInput::GenericInput(const bitpit::Config::Section & rootXML){
 
    m_readFromFile  = false;
    m_csv           = false;
    m_portsType     = BaseManipulation::ConnectionType::BOTH;
    m_name             = "mimmo.GenericInput";
    m_dir       = "./";
    m_filename  = "input.txt";
 
    std::string fallback_name = "ClassNONE";
    std::string input = rootXML.get("ClassName", fallback_name);
    input = bitpit::utils::string::trim(input);
    if(input == "mimmo.GenericInput"){
        absorbSectionXML(rootXML);
    }else{
        warningXML(m_log, m_name);
    };
}
 
GenericInput::GenericInput(std::string dir, std::string filename, bool csv){
    m_name          = "mimmo.GenericInput";
    m_readFromFile  = true;
    m_csv           = csv;
    m_dir           = dir;
    m_filename      = filename;
    m_portsType     = BaseManipulation::ConnectionType::BOTH;
};
 
GenericInput::~GenericInput(){};
 
GenericInput::GenericInput(const GenericInput & other):BaseManipulation(other){
    m_readFromFile  = other.m_readFromFile;
    m_csv           = other.m_csv;
    m_dir           = other.m_dir;
    m_filename      = other.m_filename;
};
 
GenericInput & GenericInput::operator=(GenericInput other){
    swap(other);
    return *this;
}
 
void GenericInput::swap(GenericInput & x) noexcept
{
    std::swap(m_readFromFile, x.m_readFromFile);
    std::swap(m_csv         , x.m_csv);
    std::swap(m_dir         , x.m_dir);
    std::swap(m_filename    , x.m_filename);
    std::swap(m_input       , x.m_input);
    std::swap(m_result      , x.m_result);
    BaseManipulation::swap(x);
}
 
void
GenericInput::setReadFromFile(bool readFromFile){
    m_readFromFile = readFromFile;
};
 
void
GenericInput::setFilename(std::string filename){
    m_filename = filename;
};
 
void
GenericInput::setReadDir(std::string dir){
    m_dir = dir;
};
 
void
GenericInput::setCSV(bool csv){
    m_csv = csv;
};
 
void
GenericInput::buildPorts(){
 
    bool built = true;
 
    built = (built && createPortOut<dvecarr3E, GenericInput>(this, &mimmo::GenericInput::getResult<dvecarr3E>, M_COORDS));
    built = (built && createPortOut<dvecarr3E, GenericInput>(this, &mimmo::GenericInput::getResult<dvecarr3E>, M_DISPLS));
    built = (built && createPortOut<dvector1D, GenericInput>(this, &mimmo::GenericInput::getResult<dvector1D>, M_DATAFIELD));
    built = (built && createPortOut<darray3E, GenericInput>(this, &mimmo::GenericInput::getResult<darray3E>, M_POINT));
    built = (built && createPortOut<darray3E, GenericInput>(this, &mimmo::GenericInput::getResult<darray3E>, M_SPAN));
    built = (built && createPortOut<iarray3E, GenericInput>(this, &mimmo::GenericInput::getResult<iarray3E>, M_DIMENSION));;
    built = (built && createPortOut<double, GenericInput>(this, &mimmo::GenericInput::getResult<double>, M_VALUED));
    built = (built && createPortOut<int, GenericInput>(this, &mimmo::GenericInput::getResult<int>, M_VALUEI));
    built = (built && createPortOut<bool, GenericInput>(this, &mimmo::GenericInput::getResult<bool>, M_VALUEB));
    built = (built && createPortOut<iarray3E, GenericInput>(this, &mimmo::GenericInput::getResult<iarray3E>, M_DEG));
 
    m_arePortsBuilt = built;
}
 
void
GenericInput::clearInput(){
    m_input.reset(nullptr);
}
 
void
GenericInput::clearResult(){
    m_result.reset(nullptr);
}
 
void
GenericInput::execute(){};
 
void
GenericInput::absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name){
 
    BITPIT_UNUSED(name);
 
    std::string input;
 
    BaseManipulation::absorbSectionXML(slotXML, name);
 
    if(slotXML.hasOption("ReadFromFile")){
        std::string input = slotXML.get("ReadFromFile");
        input = bitpit::utils::string::trim(input);
        bool temp = false;
        if(!input.empty()){
            std::stringstream ss(input);
            ss>>temp;
        }
        setReadFromFile(temp);
    };
 
    if(slotXML.hasOption("CSV")){
        std::string input = slotXML.get("CSV");
        input = bitpit::utils::string::trim(input);
        bool temp = false;
        if(!input.empty()){
            std::stringstream ss(input);
            ss>>temp;
        }
        setCSV(temp);
    };
 
    if(slotXML.hasOption("Filename") && m_readFromFile){
        std::string input = slotXML.get("Filename");
        input = bitpit::utils::string::trim(input);
        setFilename(input);
    };
 
    if(slotXML.hasOption("ReadDir") && m_readFromFile){
        std::string input = slotXML.get("ReadDir");
        input = bitpit::utils::string::trim(input);
        setReadDir(input);
    };
 
}
 
void
GenericInput::flushSectionXML(bitpit::Config::Section & slotXML, std::string name){
 
    BITPIT_UNUSED(name);
 
    BaseManipulation::flushSectionXML(slotXML, name);
 
    slotXML.set("ReadFromFile", std::to_string((int)m_readFromFile));
    slotXML.set("CSV", std::to_string((int)m_csv));
    slotXML.set("ReadDir", m_dir);
    slotXML.set("Filename", m_filename);
};
 
 
GenericInputMPVData::GenericInputMPVData(bool csv){
    m_csv           = csv;
    m_portsType     = BaseManipulation::ConnectionType::BOTH;
    m_name          = "mimmo.GenericInputMPVData";
    m_dir           = "./";
    m_binary        = false;
};
 
GenericInputMPVData::GenericInputMPVData(const bitpit::Config::Section & rootXML){
 
    m_csv           = false;
    m_portsType     = BaseManipulation::ConnectionType::BOTH;
    m_name             = "mimmo.GenericInputMPVData";
    m_dir       = "./";
    m_filename  = "input.txt";
    m_binary        = false;
 
    std::string fallback_name = "ClassNONE";
    std::string input = rootXML.get("ClassName", fallback_name);
    input = bitpit::utils::string::trim(input);
    if(input == "mimmo.GenericInputMPVData"){
        absorbSectionXML(rootXML);
    }else{
        warningXML(m_log, m_name);
    };
}
 
GenericInputMPVData::GenericInputMPVData(std::string dir, std::string filename, bool csv){
    m_csv           = csv;
    m_dir           = dir;
    m_filename      = filename;
    m_name          = "mimmo.GenericInputMPVData";
    m_binary        = false;
    m_portsType     = BaseManipulation::ConnectionType::BOTH;
};
 
GenericInputMPVData::~GenericInputMPVData(){};
 
GenericInputMPVData::GenericInputMPVData(const GenericInputMPVData & other):BaseManipulation(other){
    m_csv           = other.m_csv;
    m_dir           = other.m_dir;
    m_filename      = other.m_filename;
    m_binary        = other.m_binary;
};
 
GenericInputMPVData & GenericInputMPVData::operator=(GenericInputMPVData other){
    swap(other);
    return *this;
}
 
void GenericInputMPVData::swap(GenericInputMPVData & x) noexcept
{
    std::swap(m_csv         , x.m_csv);
    std::swap(m_dir         , x.m_dir);
    std::swap(m_filename    , x.m_filename);
    std::swap(m_binary      , x.m_binary);
    std::swap(m_result      , x.m_result);
    BaseManipulation::swap(x);
}
 
 
void
GenericInputMPVData::setCSV(bool csv){
    m_csv = csv;
};
 
void
GenericInputMPVData::setBinary(bool binary){
    m_binary = binary;
};
 
void
GenericInputMPVData::setFilename(std::string filename){
    m_filename = filename;
};
 
void
GenericInputMPVData::setReadDir(std::string dir){
    m_dir = dir;
};
 
void
GenericInputMPVData::buildPorts(){
 
    bool built = true;
 
    built = (built && createPortIn<MimmoSharedPointer<MimmoObject>, GenericInputMPVData>(this, &mimmo::GenericInputMPVData::setGeometry, M_GEOM));
    built = (built && createPortOut<dmpvector1D*, GenericInputMPVData>(this, &mimmo::GenericInputMPVData::getResult<double>, M_SCALARFIELD));
    built = (built && createPortOut<dmpvecarr3E*, GenericInputMPVData>(this, &mimmo::GenericInputMPVData::getResult<darray3E>, M_VECTORFIELD));
 
 
    m_arePortsBuilt = built;
}
 
void
GenericInputMPVData::clearResult(){
    m_result.reset(nullptr);
}
 
void
GenericInputMPVData::execute(){};
 
void
GenericInputMPVData::absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name){
 
    BITPIT_UNUSED(name);
 
    std::string input;
 
    BaseManipulation::absorbSectionXML(slotXML, name);
 
    if(slotXML.hasOption("CSV")){
        std::string input = slotXML.get("CSV");
        input = bitpit::utils::string::trim(input);
        bool temp = false;
        if(!input.empty()){
            std::stringstream ss(input);
            ss>>temp;
        }
        setCSV(temp);
    };
 
    if(slotXML.hasOption("Filename")){
        std::string input = slotXML.get("Filename");
        input = bitpit::utils::string::trim(input);
        setFilename(input);
    };
 
    if(slotXML.hasOption("ReadDir")){
        std::string input = slotXML.get("ReadDir");
        input = bitpit::utils::string::trim(input);
        setReadDir(input);
    };
 
    if(slotXML.hasOption("Binary")){
        std::string input = slotXML.get("Binary");
        input = bitpit::utils::string::trim(input);
        bool temp = false;
        if(!input.empty()){
            std::stringstream ss(input);
            ss>>temp;
        }
        setBinary(temp);
    };
 
}
 
void
GenericInputMPVData::flushSectionXML(bitpit::Config::Section & slotXML, std::string name){
 
    BITPIT_UNUSED(name);
 
    BaseManipulation::flushSectionXML(slotXML, name);
 
    slotXML.set("CSV", std::to_string((int)m_csv));
    slotXML.set("ReadDir", m_dir);
    slotXML.set("Filename", m_filename);
    slotXML.set("Binary", std::to_string((int)m_binary));
};
 
}