BaseManipulation.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 __BASEMANIPULATION_HPP__
#define __BASEMANIPULATION_HPP__
 
#include "MimmoNamespace.hpp"
#include "MimmoObject.hpp"
#include "InOut.hpp"
#include "MimmoPiercedVector.hpp"
 
#include <factory.hpp>
#include <portManager.hpp>
 
#include <bitpit_common.hpp>
 
#include <string>
#include <functional>
#include <unordered_map>
#include <typeinfo>
#include <type_traits>
 
#if MIMMO_ENABLE_MPI
    #include <mpi.h>
#endif
 
#if defined(_WIN32)
    #define uint unsigned int
#endif
 
namespace mimmo{
 
class BaseManipulation{
 
    friend bool pin::addPin(BaseManipulation* objSend, BaseManipulation* objRec, PortID portS, PortID portR, bool forced);
    friend void pin::removePin(BaseManipulation* objSend, BaseManipulation* objRec, PortID portS, PortID portR);
    friend void pin::removeAllPins(BaseManipulation* objSend, BaseManipulation* objRec);
    friend bool pin::checkCompatibility(BaseManipulation* objSend, BaseManipulation* objRec, PortID portS, PortID portR);
    friend void PortOut::exec();
    friend void mimmo::setLogger(std::string log);
    friend void mimmo::setLoggerDirectory(std::string dir);
 
public:
    //type definitions
    typedef std::unordered_map<BaseManipulation*, int>    bmumap;            
    typedef pin::ConnectionType                           ConnectionType;    
    typedef std::string                                   PortID;            
protected:
    uint                            m_priority;         
    std::string                     m_name;             
    int                             m_counter;          
    MimmoSharedPointer<MimmoObject> m_geometry;         
    bmumap                          m_parent;           
    bmumap                          m_child;            
    ConnectionType                  m_portsType;        
    std::unordered_map<PortID, PortIn*>   m_portIn;         
    std::unordered_map<PortID, PortOut*>  m_portOut;        
    bool                                  m_arePortsBuilt;  
    bool                        m_active;        
    bool                        m_execPlot;      
    bool                        m_apply;         
    std::string                 m_outputPlot;    
    bitpit::Logger*             m_log;           
    //static members
    static  int                 sm_baseManipulationCounter;     
#if MIMMO_ENABLE_MPI
    int                         m_nprocs;           
    int                         m_rank;             
    MPI_Comm                    m_communicator;     
#endif
 
 
public:
    BaseManipulation();
    virtual ~BaseManipulation();
 
    BaseManipulation(const BaseManipulation & other);
    BaseManipulation & operator=(const BaseManipulation & other);
 
    bitpit::Logger& getLog();
 
    bool                 arePortsBuilt();
 
    uint                 getPriority();
    std::string          getName();
    MimmoSharedPointer<MimmoObject>         getGeometry();
    MimmoSharedPointer<MimmoObject>&        getGeometryReference();
    int                  getNParent();
    BaseManipulation*    getParent(int i = 0);
    bool                 isParent(BaseManipulation *, int&);
    int                  getNChild();
    BaseManipulation*    getChild(int i = 0);
    bool                 isChild(BaseManipulation *, int&);
    ConnectionType       getConnectionType();
    int                  getNPortsIn();
    int                  getNPortsOut();
 
#if MIMMO_ENABLE_MPI
    int                 getProcessorCount();
    int                 getRank();
    MPI_Comm &          getCommunicator();
#endif
 
 
    std::unordered_map<PortID, PortIn*> getPortsIn();
    std::unordered_map<PortID, PortOut*>getPortsOut();
 
    bool    isPlotInExecution();
    bool    isActive();
    bool    isApply();
    int     getId();
 
    void    setLog(bitpit::Logger& log);
    void    setPriority(uint priority);
    void    setName(std::string name);
    void    setGeometry(MimmoSharedPointer<MimmoObject> geometry);
    void    setPlotInExecution(bool);
    void    setOutputPlot(std::string path);
    void    setId(int );
    void    setApply(bool flag = true);
 
    void    activate();
    void    disable();
 
    void    unsetGeometry();
    void    removePins();
    void    removePinsIn();
    void    removePinsOut();
    void    clear();
 
    void    exec();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name = "");
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name= "");
 
    virtual std::vector<BaseManipulation*> getSubBlocksEmbedded();
 
protected:
 
    void swap(BaseManipulation & x) noexcept;
    void initializeLogger(bool logexists);
 
    virtual void     buildPorts() = 0;
    void             deletePorts();
 
    template<typename T, typename O>
    bool    createPortOut(O* obj, T (O::*getVar_)(), PortID portS);
 
    template<typename T, typename O>
    bool    createPortOut(T* var_, PortID portS);
 
    template<typename T, typename O>
    bool    createPortIn(T* var_, PortID portR, bool mandatory = false, int family = 0);
 
    template<typename T, typename O>
    bool    createPortIn(O* obj, void (O::*setVar_)(T), PortID portR, bool mandatory = false, int family = 0);
 
    void    setBufferIn(PortID port, mimmo::IBinaryStream& input);
    void    readBufferIn(PortID port);
    void    cleanBufferIn(PortID port);
 
    void    addParent(BaseManipulation* parent);
    void    addChild(BaseManipulation* child);
    void    unsetParent(BaseManipulation * parent);
    void    unsetChild(BaseManipulation * child);
 
    PortID   findPinIn(PortIn& pin);
    PortID   findPinOut(PortOut& pin);
 
    void    addPinIn(BaseManipulation* objIn, PortID portR);
    void    addPinOut(BaseManipulation* objOut, PortID portS, PortID portR);
 
    void    removePinIn(BaseManipulation* objIn, PortID portR);
    void    removePinOut(BaseManipulation* objOut, PortID portS);
 
    void    removePinIn(PortID portR, int j);
    void    removePinOut(PortID portS, int j);
 
    virtual void    execute() = 0;
    virtual void    plotOptionalResults();
    virtual void    apply();
    void            _apply(MimmoPiercedVector<darray3E> & displacements);
 
 
    void            write(MimmoSharedPointer<MimmoObject> geometry);
 
    template<typename mpv_t, typename... Args>
    void            write(MimmoSharedPointer<MimmoObject> geometry, MimmoPiercedVector<mpv_t> & data, Args ... args);
 
    template<typename mpv_t>
    void            write(MimmoSharedPointer<MimmoObject> geometry, MimmoPiercedVector<mpv_t> & data);
 
    template<typename mpv_t, typename... Args>
    void            write(MimmoSharedPointer<MimmoObject> geometry, std::vector<MimmoPiercedVector<mpv_t>> & data, Args ... args);
 
    template<typename mpv_t>
    void            write(MimmoSharedPointer<MimmoObject> geometry, std::vector<MimmoPiercedVector<mpv_t>> & data);
 
    template<typename mpv_t, typename... Args>
    void            write(MimmoSharedPointer<MimmoObject> geometry, std::vector<MimmoPiercedVector<mpv_t>*> & data, Args ... args);
 
    template<typename mpv_t>
    void            write(MimmoSharedPointer<MimmoObject> geometry, std::vector<MimmoPiercedVector<mpv_t>*> & data);
 
};
 
 
};
 
#include "BaseManipulation.tpp"
 
 
#endif /* __BASEMANIPULATION_HPP__ */