TranslationPoint.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 "TranslationPoint.hpp"
 
namespace mimmo{
 
TranslationPoint::TranslationPoint(darray3E direction){
    setDirection(direction);
    m_alpha = 0.0;
    m_name = "mimmo.TranslationPoint";
};
 
TranslationPoint::TranslationPoint(const bitpit::Config::Section & rootXML){
 
    m_direction.fill(0.0);
    m_alpha = 0.0;
    m_name = "mimmo.TranslationPoint";
 
    std::string fallback_name = "ClassNONE";
    std::string input = rootXML.get("ClassName", fallback_name);
    input = bitpit::utils::string::trim(input);
    if(input == "mimmo.TranslationPoint"){
        absorbSectionXML(rootXML);
    }else{
        warningXML(m_log, m_name);
    };
}
 
TranslationPoint::~TranslationPoint(){};
 
TranslationPoint::TranslationPoint(const TranslationPoint & other):BaseManipulation(other){
    m_origin = other.m_origin;
    m_alpha = other.m_alpha;
    m_direction = other.m_direction;
};
 
void TranslationPoint::swap(TranslationPoint & x) noexcept
{
    std::swap(m_origin, x.m_origin);
    std::swap(m_alpha, x.m_alpha);
    std::swap(m_direction, x.m_direction);
    std::swap(m_translated, x.m_translated);
 
    BaseManipulation::swap(x);
}
 
void
TranslationPoint::buildPorts(){
    bool built = true;
    built = (built && createPortIn<darray3E, TranslationPoint>(this, &mimmo::TranslationPoint::setOrigin, M_POINT));
    built = (built && createPortIn<darray3E, TranslationPoint>(this, &mimmo::TranslationPoint::setDirection, M_AXIS));
    built = (built && createPortIn<double, TranslationPoint>(this, &mimmo::TranslationPoint::setTranslation, M_VALUED));
    built = (built && createPortOut<darray3E, TranslationPoint>(this, &mimmo::TranslationPoint::getTranslatedOrigin, M_POINT));
    // built = (built && createPortOut<darray3E, TranslationPoint>(this, &mimmo::TranslationPoint::getDirection, M_AXIS));
    // built = (built && createPortOut<double, TranslationPoint>(this, &mimmo::TranslationPoint::getTranslation, M_VALUED));
    m_arePortsBuilt = built;
};
 
darray3E
TranslationPoint::getDirection(){
    return(m_direction);
}
 
double
TranslationPoint::getTranslation(){
    return(m_alpha);
}
 
darray3E
TranslationPoint::getOrigin(){
    return(m_origin);
}
 
darray3E
TranslationPoint::getTranslatedOrigin(){
    return(m_translated);
}
 
void
TranslationPoint::setDirection(darray3E direction){
    m_direction = direction;
    double norm = norm2(m_direction);
    if(norm < std::numeric_limits<double>::min()){
        m_direction /= norm;
    }
}
 
void
TranslationPoint::setTranslation(double alpha){
    m_alpha = alpha;
}
 
void
TranslationPoint::setOrigin(darray3E origin){
    m_origin = origin;
}
 
void
TranslationPoint::execute(){
    m_translated = m_origin + m_alpha*m_direction;
};
 
void
TranslationPoint::absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name){
 
    BITPIT_UNUSED(name);
 
    BaseManipulation::absorbSectionXML(slotXML, name);
 
    if(slotXML.hasOption("Origin")){
        std::string input = slotXML.get("Origin");
        input = bitpit::utils::string::trim(input);
        darray3E temp = {{0.0,0.0,0.0}};
        if(!input.empty()){
            std::stringstream ss(input);
            for(auto &val : temp) ss>>val;
        }
        setOrigin(temp);
    }
 
    if(slotXML.hasOption("Direction")){
        std::string input = slotXML.get("Direction");
        input = bitpit::utils::string::trim(input);
        darray3E temp = {{0.0,0.0,0.0}};
        if(!input.empty()){
            std::stringstream ss(input);
            for(auto &val : temp) ss>>val;
        }
        setDirection(temp);
    }
 
    if(slotXML.hasOption("Translation")){
        std::string input = slotXML.get("Translation");
        input = bitpit::utils::string::trim(input);
        double temp = 0.0;
        if(!input.empty()){
            std::stringstream ss(input);
            ss>>temp;
        }
        setTranslation(temp);
    }
 
};
 
void
TranslationPoint::flushSectionXML(bitpit::Config::Section & slotXML, std::string name){
 
    BITPIT_UNUSED(name);
 
    BaseManipulation::flushSectionXML(slotXML, name);
 
    {
        std::stringstream ss;
        ss<<std::scientific<<m_origin[0]<<'\t'<<m_origin[1]<<'\t'<<m_origin[2];
        slotXML.set("Origin", ss.str());
    }
 
    {
        std::stringstream ss;
        ss<<std::scientific<<m_direction[0]<<'\t'<<m_direction[1]<<'\t'<<m_direction[2];
        slotXML.set("Direction", ss.str());
    }
 
    slotXML.set("Translation", std::to_string(m_alpha));
 
};
 
 
}