BaseManipulation.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 "BaseManipulation.hpp"
#include <utility>
#include <map>
 
namespace mimmo {
 
int BaseManipulation::sm_baseManipulationCounter(1);
 
BaseManipulation::BaseManipulation(){
    m_geometry      = nullptr;
    m_portsType     = ConnectionType::BOTH;
    m_name          = "mimmo";
    m_active        = true;
    m_arePortsBuilt = false;
    m_execPlot      = false;
    m_outputPlot    = "./";
    m_counter       = sm_baseManipulationCounter;
    m_priority      = 0;
    m_apply         = false;
    sm_baseManipulationCounter++;
 
#if MIMMO_ENABLE_MPI
    int initialized;
    MPI_Initialized(&initialized);
    if (!initialized)
       MPI_Init(nullptr, nullptr);
 
    //Fixed MPI comm world
    MPI_Comm_dup(MPI_COMM_WORLD, &m_communicator);
 
    MPI_Comm_rank(MPI_COMM_WORLD, &m_rank);
    MPI_Comm_size(MPI_COMM_WORLD, &m_nprocs);
 
#endif
 
    bool logexists  = bitpit::log::manager().exists(MIMMO_LOG_FILE);
    if (m_counter == 1)
        initializeLogger(logexists);
    else
        m_log = &bitpit::log::cout(MIMMO_LOG_FILE);
 
};
 
BaseManipulation::~BaseManipulation(){
    clear();
    deletePorts();
};
 
BaseManipulation::BaseManipulation(const BaseManipulation & other){
    m_geometry      = other.m_geometry;
    m_portsType     = other.m_portsType;
    m_name          = other.m_name;
    m_active        = other.m_active;
    m_arePortsBuilt = false;
    m_execPlot      = other.m_execPlot;
    m_outputPlot    = other.m_outputPlot;
 
    //only for copy construction
    m_counter       = sm_baseManipulationCounter;
    sm_baseManipulationCounter++;
 
    m_priority      = other.m_priority;
    m_apply         = other.m_apply;
 
    //logger is ready, since another BaseManipulation other, is instantiated.
    m_log           = &bitpit::log::cout(MIMMO_LOG_FILE);
 
#if MIMMO_ENABLE_MPI
    m_rank = other.m_rank;
    m_nprocs = other.m_nprocs;
    MPI_Comm_dup(other.m_communicator, &m_communicator);
#endif
};
 
BaseManipulation & BaseManipulation::operator=(const BaseManipulation & other){
 
    //NOT CAS type, since the class is abstract.
    //Please note static members or link to static members are not copied.
    //Port connection and port building members are not copied.
    m_geometry      = other.m_geometry;
    m_portsType     = other.m_portsType;
    m_name          = other.m_name;
    m_active        = other.m_active;
    m_execPlot      = other.m_execPlot;
    m_outputPlot    = other.m_outputPlot;
    m_priority      = other.m_priority;
    m_apply         = other.m_apply;
#if MIMMO_ENABLE_MPI
    MPI_Comm_dup(other.m_communicator, &m_communicator);
    m_rank          = other.m_rank;
    m_nprocs        = other.m_nprocs;
#endif
    return  *this;
};
 
void BaseManipulation::swap(BaseManipulation & x) noexcept
{
    std::swap(m_priority, x.m_priority);
    std::swap(m_name, x.m_name);
    m_geometry.swap(x.m_geometry);
    std::swap(m_portsType, x.m_portsType);
    std::swap(m_active, x.m_active);
    std::swap(m_execPlot, x.m_execPlot);
    std::swap(m_apply, x.m_apply);
    std::swap(m_outputPlot, x.m_outputPlot);
#if MIMMO_ENABLE_MPI
    std::swap(m_communicator, x.m_communicator);
    std::swap(m_rank, x.m_rank);
    std::swap(m_nprocs, x.m_nprocs);
#endif
 
}
 
void
BaseManipulation::initializeLogger(bool logexist){
    if (!logexist){
#if MIMMO_ENABLE_MPI
        bitpit::log::manager().initialize(bitpit::log::Mode::COMBINED, MIMMO_LOG_FILE, true, MIMMO_LOG_DIR, m_nprocs, m_rank);
#else
        bitpit::log::manager().initialize(bitpit::log::Mode::COMBINED, MIMMO_LOG_FILE, true, MIMMO_LOG_DIR);
#endif
    }
    m_log = &bitpit::log::cout(MIMMO_LOG_FILE);
    bitpit::log::setVisibility((*m_log), bitpit::log::Visibility::MASTER);
    bitpit::log::setConsoleVerbosity((*m_log), bitpit::log::NORMAL);
    bitpit::log::setFileVerbosity((*m_log), bitpit::log::NORMAL);
    if (m_counter == 1){
#if MIMMO_ENABLE_MPI
        if (m_rank == 0){
#endif
        (*m_log) << bitpit::log::priority(bitpit::log::NORMAL);
        (*m_log) << bitpit::log::context("mimmo");
        (*m_log) << "--------------------------------------------------" << std::endl;
        (*m_log) << "- mimmo - Surface manipulation and mesh morphing -" << std::endl;
        (*m_log) << "--------------------------------------------------" << std::endl;
        (*m_log) << "    " << std::endl;
        (*m_log) << bitpit::log::priority(bitpit::log::DEBUG);
#if MIMMO_ENABLE_MPI
        }
#endif
    }
}
 
bitpit::Logger&
BaseManipulation::getLog(){
    return (*m_log);
}
 
bool
BaseManipulation::arePortsBuilt(){
    return(m_arePortsBuilt);
}
 
uint
BaseManipulation::getPriority(){
    return m_priority;
}
 
std::string
BaseManipulation::getName(){
    return m_name;
};
 
MimmoSharedPointer<MimmoObject>
BaseManipulation::getGeometry(){
    return m_geometry;
};
 
MimmoSharedPointer<MimmoObject> &
BaseManipulation::getGeometryReference(){
    return m_geometry;
};
 
int
BaseManipulation::getNParent(){
    return m_parent.size();
};
 
BaseManipulation*
BaseManipulation::getParent(int i){
    if (i>(int)m_parent.size()-1) return nullptr;
    return next(m_parent.begin(), i)->first;
};
 
bool
BaseManipulation::isParent(BaseManipulation * target, int &index){
    std::unordered_map<BaseManipulation *, int>::iterator it;
    it = m_parent.find(target);
    index = -1;
    if(it == m_parent.end()) return false;
 
    index = distance(m_parent.begin(), it);
    return true;
};
 
int
BaseManipulation::getNChild(){
    return m_child.size();
};
 
BaseManipulation*
BaseManipulation::getChild(int i){
    if (i>(int)m_child.size()-1) return nullptr;
    return next(m_child.begin(), i)->first;
};
 
bool
BaseManipulation::isChild(BaseManipulation * target, int &index){
    std::unordered_map<BaseManipulation *, int>::iterator it;
    it = m_child.find(target);
    index = -1;
    if(it == m_child.end()) return false;
 
    index = distance(m_child.begin(), it);
    return true;
};
 
BaseManipulation::ConnectionType
BaseManipulation::getConnectionType(){
    return (m_portsType);
}
 
int
BaseManipulation::getNPortsIn(){
    return (m_portIn.size());
}
 
int
BaseManipulation::getNPortsOut(){
    return (m_portOut.size());
}
 
std::unordered_map<PortID, PortIn*>
BaseManipulation::getPortsIn(){
    return (m_portIn);
}
 
std::unordered_map<PortID, PortOut*>
BaseManipulation::getPortsOut(){
    return (m_portOut);
}
 
bool
BaseManipulation::isPlotInExecution(){
    return (m_execPlot);
}
 
bool
BaseManipulation::isApply(){
    return (m_apply);
}
 
bool
BaseManipulation::isActive(){
    return (m_active);
}
 
 
int
BaseManipulation::getId(){
    return m_counter;
}
 
void
BaseManipulation::setLog(bitpit::Logger& log){
    m_log = &log;
}
 
void
BaseManipulation::setPriority(uint priority){
    m_priority = priority;
};
 
void
BaseManipulation::setName(std::string name){
    m_name = name;
};
 
void
BaseManipulation::setGeometry(MimmoSharedPointer<MimmoObject> geometry){
    m_geometry = geometry;
};
 
void
BaseManipulation::setPlotInExecution( bool flag){
    m_execPlot = flag;
}
 
void
BaseManipulation::setOutputPlot(std::string path){
    if(path.empty())    path = ".";
    m_outputPlot = path;
}
 
void
BaseManipulation::setApply( bool flag){
    m_apply = flag;
}
 
void
BaseManipulation::setId(int id){
    m_counter = id;
}
 
void
BaseManipulation::activate(){
    m_active = true;
};
 
void
BaseManipulation::disable(){
    m_active = false;
};
 
void
BaseManipulation::unsetGeometry(){
    m_geometry = nullptr;
};
 
void
BaseManipulation::removePins(){
    removePinsIn();
    removePinsOut();
}
 
void
BaseManipulation::removePinsIn(){
    std::unordered_map<BaseManipulation*, int>::iterator it;
    while(m_parent.size()){
        it = m_parent.begin();
        mimmo::pin::removeAllPins(it->first, this);
    }
}
 
void
BaseManipulation::removePinsOut(){
    std::unordered_map<BaseManipulation*, int>::iterator it;
    while(m_child.size()){
        it = m_child.begin();
        mimmo::pin::removeAllPins(this, it->first);
    }
}
 
void
BaseManipulation::clear(){
    unsetGeometry();
    removePins();
    m_execPlot = false;
    m_outputPlot = ".";
};
 
void
BaseManipulation::exec(){
 
    if (!MIMMO_EXPERT){
        std::map<int, std::vector<PortIn*> > families;
        std::map<int, std::vector<PortID> > familiesID;
        for (std::unordered_map<PortID, PortIn*>::iterator i=m_portIn.begin(); i!=m_portIn.end(); i++){
            if (i->second->isMandatory()){
                families[i->second->getFamily()].push_back(i->second);
                familiesID[i->second->getFamily()].push_back(i->first);
            }
        }
        std::map<int, std::vector<PortID> >::iterator itID = familiesID.begin();
        for (std::map<int, std::vector<PortIn*> >::iterator i=families.begin(); i!=families.end(); i++){
            if (i->first == 0){
                int count = 0;
                for (auto ip : i->second){
                    std::vector<BaseManipulation*>  linked = ip->getLink();
                    if (linked.size() == 0){
                        (*m_log) << "error: " << m_name << " mandatory port " << itID->second[count] << " not linked -> exit! " << std::endl;
                        throw std::runtime_error (m_name + " mandatory port " + itID->second[count] + " not linked");
                    }
                    count++;
                }
            }
            else{
                bool check = false;
                for (auto ip : i->second){
                    std::vector<BaseManipulation*>  linked = ip->getLink();
                    check = check || linked.size();
                }
                if (!check){
                    (*m_log) << "error: " << m_name << " none of mandatory ports " << itID->second << " linked -> exit! " << std::endl;
                    std::string ports;
                    for (auto p : itID->second)
                        ports += " " + p + " ";
                    throw std::runtime_error (m_name + " none of mandatory ports " + ports + " linked");
                }
            }
            itID++;
        }
    }
 
    if (m_active) execute();
 
    for (std::unordered_map<PortID, PortOut*>::iterator i=m_portOut.begin(); i!=m_portOut.end(); i++){
        std::vector<BaseManipulation*>  linked = i->second->getLink();
        if (linked.size() > 0){
            i->second->exec();
        }
    }
 
    if(isPlotInExecution()) plotOptionalResults();
    if(isApply()) apply();
}
 
void
BaseManipulation::absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name){
    BITPIT_UNUSED(name);
 
    std::string input;
    if(slotXML.hasOption("Priority")){
        input = slotXML.get("Priority");
        int value =0;
        if(!input.empty()){
            std::stringstream ss(bitpit::utils::string::trim(input));
            ss>>value;
        }
        setPriority(value);
    };
 
 
    if(slotXML.hasOption("Apply")){
        std::string input = slotXML.get("Apply");
        input = bitpit::utils::string::trim(input);
        bool value = false;
        if(!input.empty()){
            std::stringstream ss(input);
            ss >> value;
        }
        setApply(value);
    }
 
    if(slotXML.hasOption("PlotInExecution")){
        std::string input = slotXML.get("PlotInExecution");
        input = bitpit::utils::string::trim(input);
        bool value = false;
        if(!input.empty()){
            std::stringstream ss(input);
            ss >> value;
        }
        setPlotInExecution(value);
    }
 
    if(slotXML.hasOption("OutputPlot")){
        std::string input = slotXML.get("OutputPlot");
        input = bitpit::utils::string::trim(input);
        std::string temp = ".";
        if(!input.empty())  setOutputPlot(input);
        else                setOutputPlot(temp);
    }
 
}
 
void
BaseManipulation::flushSectionXML(bitpit::Config::Section & slotXML, std::string name){
 
    BITPIT_UNUSED(name);
 
    slotXML.set("ClassName", m_name);
    slotXML.set("Priority", std::to_string(getPriority()));
 
    if(isApply()){
        slotXML.set("Apply", std::to_string(1));
    }
    if(isPlotInExecution()){
        slotXML.set("PlotInExecution", std::to_string(1));
        slotXML.set("OutputPlot", m_outputPlot);
    }
}
 
void
BaseManipulation::deletePorts(){
    for (std::unordered_map<PortID, PortOut*>::iterator i = m_portOut.begin(); i != m_portOut.end(); i++){
        delete i->second;
        i->second = nullptr;
    }
    for (std::unordered_map<PortID, PortIn*>::iterator i = m_portIn.begin(); i != m_portIn.end(); i++){
        delete i->second;
        i->second = nullptr;
    }
}
 
void
BaseManipulation::setBufferIn(PortID port, mimmo::IBinaryStream& input){
    m_portIn[port]->m_ibuffer = input;
}
 
void
BaseManipulation::readBufferIn(PortID port){
    m_portIn[port]->readBuffer();
}
 
void
BaseManipulation::cleanBufferIn(PortID port){
    m_portIn[port]->cleanBuffer();
}
 
void
BaseManipulation::addParent(BaseManipulation* parent){
 
    if(!m_parent.count(parent)){
        m_parent.insert(std::pair<BaseManipulation*,int>(parent,1)); //add new parent with counter 1;
    }else{
        m_parent[parent]++; //just incrementing pre-existent parent counter;
    }
};
 
void
BaseManipulation::addChild(BaseManipulation* child){
    if(!m_child.count(child)){
        m_child.insert(std::pair<BaseManipulation*,int>(child,1)); //add new child with counter 1;
    }else{
        m_child[child]++; //just incrementing pre-existent child counter;
    }
};
 
void
BaseManipulation::unsetParent(BaseManipulation * parent){
 
    std::unordered_map<BaseManipulation*, int>::iterator got = m_parent.find(parent);
    if(got != m_parent.end()){
        m_parent[parent]--;
        if(m_parent[parent] <1) m_parent.erase(parent);
    }
};
 
void
BaseManipulation::unsetChild(BaseManipulation * child){
    std::unordered_map<BaseManipulation*, int>::iterator got = m_child.find(child);
    if(got != m_child.end()){
        m_child[child]--;
        if(m_child[child] <1) m_child.erase(child);
    }
};
 
PortID
BaseManipulation::findPinIn(PortIn& pin){
    for (std::unordered_map<PortID, PortIn*>::iterator i=m_portIn.begin(); i!=m_portIn.end(); i++){
        if (pin == *(i->second)) return(i->first);
    }
    return("NONE");
}
 
PortID
BaseManipulation::findPinOut(PortOut& pin){
    for (std::unordered_map<PortID, PortOut*>::iterator i=m_portOut.begin(); i!=m_portOut.end(); i++){
        if (pin == *(i->second)) return(i->first);
    }
    return("NONE");
}
 
void
BaseManipulation::addPinIn(BaseManipulation* objIn, PortID portR){
    if (objIn != nullptr && m_portIn.count(portR) !=0 ){
        m_portIn[portR]->m_objLink.push_back(objIn);
    }
};
 
void
BaseManipulation::addPinOut(BaseManipulation* objOut, PortID portS, PortID portR){
    if (objOut != nullptr && m_portOut.count(portS) != 0 ){
        if (objOut->m_portIn.count(portR) != 0){
            m_portOut[portS]->m_objLink.push_back(objOut);
            m_portOut[portS]->m_portLink.push_back(portR);
        }
    }
};
 
void
BaseManipulation::removePinIn(BaseManipulation* objIn, PortID portR){
    if (objIn != nullptr && m_portIn.count(portR) != 0){
        std::vector<BaseManipulation*>  linked = m_portIn[portR]->getLink();
        for (int i=0; i<(int)linked.size(); i++){
            if (linked[i] == objIn){
                m_portIn[portR]->clear(i);
            }
        }
    }
};
 
void
BaseManipulation::removePinOut(BaseManipulation* objOut, PortID portS){
    if (objOut != nullptr && m_portOut.count(portS) != 0){
        std::vector<BaseManipulation*>  linked = m_portOut[portS]->getLink();
        for (int i=0; i<(int)linked.size(); i++){
            if (linked[i] == objOut){
                m_portOut[portS]->clear(i);
            }
        }
    };
}
 
void
BaseManipulation::removePinIn(PortID portR, int j){
    if ( m_portIn.count(portR) != 0 ){
        if (j<(int)m_portIn[portR]->getLink().size() && j >= 0){
            m_portIn[portR]->clear(j);
        }
    }
}
 
void
BaseManipulation::removePinOut(PortID portS, int j){
    if ( m_portOut.count(portS) != 0 ){
        if (j<(int)m_portOut[portS]->getLink().size() && j >= 0){
            m_portOut[portS]->clear(j);
        }
    }
}
 
void    BaseManipulation::plotOptionalResults(){};
 
void    BaseManipulation::apply(){};
 
 
std::vector<BaseManipulation*>    BaseManipulation::getSubBlocksEmbedded(){
    return std::vector<BaseManipulation *>();
};
 
#if MIMMO_ENABLE_MPI
 
int BaseManipulation::getProcessorCount(){
    return m_nprocs;
}
 
int BaseManipulation::getRank(){
    return m_rank;
}
MPI_Comm &  BaseManipulation::getCommunicator(){
    return m_communicator;
}
 
#endif
 
 
void
BaseManipulation::_apply(MimmoPiercedVector<darray3E> & displacements)
{
    if (getGeometry() == nullptr) return;
    darray3E vertexcoords;
    long int ID;
    for (const auto & vertex : getGeometry()->getVertices()){
        vertexcoords = vertex.getCoords();
        ID = vertex.getId();
        if(displacements.exists(ID))     vertexcoords += displacements[ID];
        getGeometry()->modifyVertex(vertexcoords, ID);
    }
 
    // Update geometry
    getGeometry()->update();
 
}
 
void
BaseManipulation::write(MimmoSharedPointer<MimmoObject> geometry)
{
    //Check geometry
    if (geometry == nullptr){
        (*m_log) << " Warning: geometry null during writing " << m_name << std::endl;
        return;
    }
 
    bitpit::VTKUnstructuredGrid & VTK = geometry->getPatch()->getVTK();
    VTK.setDirectory(m_outputPlot+"/");
    VTK.setName(m_name+std::to_string(m_counter));
    geometry->getPatch()->write();
}
 
};