GenericOutput.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 "GenericOutput.hpp"
 
namespace mimmo{
 
GenericOutput::GenericOutput(std::string dir, std::string filename, bool csv){
    m_dir       = dir;
    m_filename  = filename;
    m_csv       = csv;
    m_portsType    = ConnectionType::BACKWARD;
    m_name         = "mimmo.GenericOutput";
};
 
GenericOutput::GenericOutput(const bitpit::Config::Section & rootXML){
 
    m_dir       = "./";
    m_filename  = "output.txt";
    m_portsType    = ConnectionType::BACKWARD;
    m_name         = "mimmo.GenericOutput";
    m_csv       = false;
 
    std::string fallback_name = "ClassNONE";
    std::string input = rootXML.get("ClassName", fallback_name);
    input = bitpit::utils::string::trim(input);
    if(input == "mimmo.GenericOutput"){
        absorbSectionXML(rootXML);
    }else{
        warningXML(m_log, m_name);
    };
}
 
GenericOutput::~GenericOutput(){};
 
GenericOutput::GenericOutput(const GenericOutput & other):BaseManipulation(other){
    m_dir           = other.m_dir;
    m_filename      = other.m_filename;
    m_csv           = other.m_csv;
};
 
GenericOutput & GenericOutput::operator=(GenericOutput other){
    swap(other);
    return *this;
}
 
void GenericOutput::swap(GenericOutput & x) noexcept
{
    std::swap(m_dir, x.m_dir);
    std::swap(m_filename, x.m_filename);
    std::swap(m_csv, x.m_csv);
    std::swap(m_input, x.m_input);
    BaseManipulation::swap(x);
}
 
void
GenericOutput::buildPorts(){
 
    bool built = true;
    built = (built && createPortIn<dvecarr3E, GenericOutput>(this, &mimmo::GenericOutput::setInput<dvecarr3E>, M_COORDS, true, 1));
    built = (built && createPortIn<dvecarr3E, GenericOutput>(this, &mimmo::GenericOutput::setInput<dvecarr3E>, M_DISPLS, true, 1));
    built = (built && createPortIn<dvector1D, GenericOutput>(this, &mimmo::GenericOutput::setInput<dvector1D>, M_DATAFIELD, true, 1));
    built = (built && createPortIn<darray3E, GenericOutput>(this, &mimmo::GenericOutput::setInput<darray3E>, M_POINT, true, 1));
    built = (built && createPortIn<darray3E, GenericOutput>(this, &mimmo::GenericOutput::setInput<darray3E>, M_SPAN, true, 1));
    built = (built && createPortIn<iarray3E, GenericOutput>(this, &mimmo::GenericOutput::setInput<iarray3E>, M_DIMENSION, true, 1));
    built = (built && createPortIn<double, GenericOutput>(this, &mimmo::GenericOutput::setInput<double>, M_VALUED, true, 1));
    built = (built && createPortIn<int, GenericOutput>(this, &mimmo::GenericOutput::setInput<int>, M_VALUEI, true, 1));
    built = (built && createPortIn<bool, GenericOutput>(this, &mimmo::GenericOutput::setInput<bool>, M_VALUEB, true, 1));
    built = (built && createPortIn<iarray3E, GenericOutput>(this, &mimmo::GenericOutput::setInput<iarray3E>, M_DEG, true, 1));
 
    m_arePortsBuilt = built;
}
 
void
GenericOutput::setWriteDir(std::string dir){
    m_dir = dir;
};
 
void
GenericOutput::setFilename(std::string filename){
    m_filename = filename;
};
 
void
GenericOutput::setCSV(bool csv){
    m_csv = csv;
};
 
 
void
GenericOutput::clearInput(){
    m_input.reset(nullptr);
}
 
void
GenericOutput::execute(){
 
    // bool ok = rename("output.txt", m_filename.c_str());
    // if (!ok)
    //     (*m_log)<<"Generic Output execution failed renaming..."<<std::endl;
};
 
void
GenericOutput::absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name){
 
    BITPIT_UNUSED(name);
    std::string input;
 
    BaseManipulation::absorbSectionXML(slotXML, name);
 
    if(slotXML.hasOption("Filename")){
        std::string input = slotXML.get("Filename");
        input = bitpit::utils::string::trim(input);
        setFilename(input);
    };
 
    if(slotXML.hasOption("WriteDir")){
        std::string input = slotXML.get("WriteDir");
        input = bitpit::utils::string::trim(input);
        setWriteDir(input);
    };
 
    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);
    };
 
}
 
void
GenericOutput::flushSectionXML(bitpit::Config::Section & slotXML, std::string name){
 
    BITPIT_UNUSED(name);
 
    BaseManipulation::flushSectionXML(slotXML, name);
 
    slotXML.set("Filename", m_filename);
    slotXML.set("WriteDir", m_dir);
    slotXML.set("CSV", std::to_string((int)m_csv));
};
 
 
GenericOutputMPVData::GenericOutputMPVData(std::string dir, std::string filename, bool csv){
    m_dir       = dir;
    m_filename  = filename;
    m_csv       = csv;
    m_portsType    = ConnectionType::BACKWARD;
    m_name         = "mimmo.GenericOutputMPVData";
    m_binary        = false;
};
 
GenericOutputMPVData::GenericOutputMPVData(const bitpit::Config::Section & rootXML){
 
    m_dir       = "./";
    m_filename  = "output.txt";
    m_portsType    = ConnectionType::BACKWARD;
    m_name         = "mimmo.GenericOutputMPVData";
    m_csv       = false;
    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.GenericOutputMPVData"){
        absorbSectionXML(rootXML);
    }else{
        warningXML(m_log, m_name);
    };
}
 
GenericOutputMPVData::~GenericOutputMPVData(){};
 
GenericOutputMPVData::GenericOutputMPVData(const GenericOutputMPVData & other):BaseManipulation(other){
    m_dir           = other.m_dir;
    m_filename      = other.m_filename;
    m_csv           = other.m_csv;
    m_binary        = other.m_binary;
};
 
GenericOutputMPVData & GenericOutputMPVData::operator=(GenericOutputMPVData other){
    swap(other);
    return *this;
}
 
void GenericOutputMPVData::swap(GenericOutputMPVData & x) noexcept
{
    std::swap(m_dir, x.m_dir);
    std::swap(m_filename, x.m_filename);
    std::swap(m_csv, x.m_csv);
    std::swap(m_binary, x.m_binary);
    std::swap(m_input, x.m_input);
    BaseManipulation::swap(x);
}
 
void
GenericOutputMPVData::buildPorts(){
 
    bool built = true;
    built = (built && createPortIn<dmpvector1D*, GenericOutputMPVData>(this, &mimmo::GenericOutputMPVData::setInput<double>, M_SCALARFIELD));
    built = (built && createPortIn<dmpvecarr3E*, GenericOutputMPVData>(this, &mimmo::GenericOutputMPVData::setInput<darray3E>, M_VECTORFIELD));
 
    m_arePortsBuilt = built;
}
 
void
GenericOutputMPVData::setWriteDir(std::string dir){
    m_dir = dir;
};
 
void
GenericOutputMPVData::setFilename(std::string filename){
    m_filename = filename;
};
 
void
GenericOutputMPVData::setCSV(bool csv){
    m_csv = csv;
};
 
void
GenericOutputMPVData::setBinary(bool binary){
    m_binary = binary;
};
 
 
void
GenericOutputMPVData::clearInput(){
    m_input.reset(nullptr);
}
 
 
void
GenericOutputMPVData::execute(){
 
    // bool ok = rename("output.txt", m_filename.c_str());
    // if (!ok)
    //     (*m_log)<<"Generic Output execution failed renaming..."<<std::endl;
};
 
void
GenericOutputMPVData::absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name){
 
    BITPIT_UNUSED(name);
    std::string input;
 
    BaseManipulation::absorbSectionXML(slotXML, name);
 
    if(slotXML.hasOption("Filename")){
        std::string input = slotXML.get("Filename");
        input = bitpit::utils::string::trim(input);
        setFilename(input);
    };
 
    if(slotXML.hasOption("WriteDir")){
        std::string input = slotXML.get("WriteDir");
        input = bitpit::utils::string::trim(input);
        setWriteDir(input);
    };
 
    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("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
GenericOutputMPVData::flushSectionXML(bitpit::Config::Section & slotXML, std::string name){
 
    BITPIT_UNUSED(name);
 
    BaseManipulation::flushSectionXML(slotXML, name);
 
    slotXML.set("Filename", m_filename);
    slotXML.set("WriteDir", m_dir);
    slotXML.set("CSV", std::to_string((int)m_csv));
    slotXML.set("Binary", std::to_string((int)m_binary));
};
 
 
}