Chain.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 "Chain.hpp"
 
namespace mimmo{
 
uint8_t Chain::sm_chaincounter(1);
 
Chain::Chain(){
    m_id            = sm_chaincounter;
    m_objcounter    = 0;
    m_objects.clear();
    m_idObjects.clear();
    sm_chaincounter++;
    m_plotDebRes = false;
    m_outputDebRes = ".";
    m_log = &bitpit::log::cout(MIMMO_LOG_FILE);
};
 
 
Chain::~Chain(){
    clear();
    --sm_chaincounter;
};
 
void Chain::swap(Chain & x) noexcept{
    std::swap(m_id,x.m_id);
    std::swap(m_objects,x.m_objects);
    std::swap(m_idObjects,x.m_idObjects);
    std::swap(m_objcounter,x.m_objcounter);
    std::swap(m_plotDebRes,x.m_plotDebRes);
    std::swap(m_outputDebRes,x.m_outputDebRes);
};
 
std::unique_ptr<Chain>  Chain::clone() const{
 
    std::unique_ptr<Chain> res(new Chain());
    res->setOutputDebugResults(m_outputDebRes);
    res->setPlotDebugResults(m_plotDebRes);
 
    int count(0);
    for(BaseManipulation * pp : m_objects){
        res->addObject(pp, m_idObjects[count]);
        ++count;
    }
    return res;
};
 
 
void
Chain::clear(){
    m_objcounter    = 0;
    m_objects.clear();
    m_idObjects.clear();
};
 
uint32_t
Chain::getNObjects(){
    return m_objects.size();
};
 
uint8_t
Chain::getID(){
    return m_id;
};
 
uint8_t
Chain::getNChains(){
    return sm_chaincounter;
};
 
int
Chain::getID(int i){
    return m_idObjects[i];
};
 
std::string
Chain::getName(int i){
    return m_objects[i]->getName();
};
 
bool
Chain::deleteObject(int idobj){
    bool cut = false;
    std::vector<int>::iterator it = std::find(m_idObjects.begin(), m_idObjects.end(), idobj);
    if (it != m_idObjects.end()){
        int idx = std::distance(m_idObjects.begin(), it);
        if (m_objects[idx]->getParent() != nullptr || m_objects[idx]->getNChild() != 0) cut = true;
        m_objects.erase(m_objects.begin()+idx);
        m_idObjects.erase(it);
    }
    return cut;
};
 
int
Chain::addObject(BaseManipulation* obj, int id_){
    int id = id_;
    if (id_ < 0){
        id = m_objcounter;
        m_objcounter++;
    }
    if (m_objects.size() == 0){
        m_objects.push_back(obj);
        m_idObjects.push_back(id);
        return 0;
    }
    std::vector<BaseManipulation*>::iterator itchild = m_objects.end();
    std::vector<BaseManipulation*>::iterator itparent;
    int idxchild = m_objects.size();
    ivector1D idxparent(obj->getNParent(), -1);
    if (obj->getNChild()>0){
        for (int i=0; i<obj->getNChild(); i++){
            itchild = std::find(m_objects.begin(), m_objects.end(), obj->getChild(i));
            if (itchild != m_objects.end()){
                idxchild = std::min(idxchild, int(std::distance(m_objects.begin(), itchild)));
            }
        }
    }
    if (obj->getNParent()>0){
        for (int i=0; i<obj->getNParent(); i++){
            if (obj->getParent(i) != nullptr){
                itparent = std::find(m_objects.begin(), m_objects.end(), obj->getParent(i));
                if (itparent != m_objects.end()){
                    idxparent[i] = std::distance(m_objects.begin(), itparent);
                }
            }
        }
    }
    for (int i=0; i<obj->getNParent(); i++){
        if (idxparent[i] == idxchild) return -1;
    }
 
    bool parentsMinor = true;
    for (int i=0; i<obj->getNParent(); i++){
        if (idxparent[i] > idxchild){
            parentsMinor = false;
        }
    }
    if (!parentsMinor){
        ivector1D idparent(obj->getNParent(), -1);
        std::vector<BaseManipulation*> parent(obj->getNParent());
        for (int i=0; i<obj->getNParent(); i++){
            if (idxparent[i] > idxchild){
                parent[i] = obj->getParent(i);
                itparent = std::find(m_objects.begin(), m_objects.end(), parent[i]);
                int idxtemp = std::distance(m_objects.begin(), itparent);
                idparent[i] = m_idObjects[idxtemp];
                m_objects.erase(itparent);
                m_idObjects.erase(m_idObjects.begin()+idxtemp);
            }
        }
        int idx = addObject(obj, id);
        for (int i=0; i<obj->getNParent(); i++){
            if (idxparent[i] > idxchild){
                addObject(parent[i], idparent[i]);
                parent[i] = nullptr;
            }
        }
        return idx+1;
    }else{
        m_objects.insert(m_objects.begin()+idxchild, obj);
        m_idObjects.insert(m_idObjects.begin()+idxchild, id);
        return idxchild;
    }
    return 0;
}
 
 
void Chain::setPlotDebugResults(bool active){
    m_plotDebRes = active;
}
 
void Chain::setOutputDebugResults(std::string path){
    m_outputDebRes = path;
}
 
bool Chain::isPlottingDebugResults(){
    return m_plotDebRes;
}
 
std::string Chain::getOutputDebugResults(){
    return m_outputDebRes;
}
 
 
void
Chain::exec(bool debug){
 
    std::vector<BaseManipulation*>::iterator it, itb = m_objects.begin();
    std::vector<BaseManipulation*>::iterator itend = m_objects.end();
    bitpit::log::Priority oldPriority = m_log->getPriority();
    if(debug)
        m_log->setPriority(bitpit::log::NORMAL);
    (*m_log) << " " << std::endl;
    (*m_log) << "--------------------------------------------------" << std::endl;
    (*m_log) << " Execution of chain - "<< m_objcounter << " objects" << std::endl;
    if(m_plotDebRes){
        (*m_log) << "--------------------------------------------------" << std::endl;
        (*m_log) << " Plotting of Debug Results is active"<< std::endl;
        (*m_log) << " Results will be stored in the directory: "<<m_outputDebRes<< std::endl;
        (*m_log) << "--------------------------------------------------" << std::endl;
    }
    (*m_log) << " " << std::endl;
    checkLoops();
    int i = 1;
    for (it = itb; it != itend; ++it){
        if(debug)
            m_log->setPriority(bitpit::log::NORMAL);
        (*m_log) << " execution object " << i << "  : " << (*it)->getName() << std::endl;
 
        if(m_plotDebRes){
            (*it)->setPlotInExecution(m_plotDebRes);
            (*it)->setOutputPlot(m_outputDebRes);
        }
        (*it)->exec();
        i++;
    }
 
    (*m_log) << " " << std::endl;
    (*m_log) << "--------------------------------------------------" << std::endl;
    (*m_log) << " " << std::endl;
    m_log->setPriority(oldPriority);
}
 
void
Chain::exec(int idobj){
    int idx = std::distance(m_idObjects.begin(), find(m_idObjects.begin(), m_idObjects.end(), idobj));
    if (idx <  (int)m_objects.size()) m_objects[idx]->exec();
}
 
void
Chain::checkLoops(){
    std::vector<BaseManipulation*>::iterator it, itb = m_objects.begin();
    std::vector<BaseManipulation*>::iterator itend = m_objects.end();
    int actualidx = 0;
    for (it = itb; it != itend; ++it){
        for (int i=0; i<(*it)->getNChild(); i++){
            int idxchild = std::distance(m_objects.begin(), std::find(m_objects.begin(), m_objects.end(), (*it)->getChild(i)));
            if (idxchild <= actualidx){
                (*m_log) << " error : loop in chain : "<< (*it)->getName() << " linked to " << (*it)->getChild(i)->getName() <<  std::endl;
                (*m_log) << " " << std::endl;
                throw std::runtime_error ("loop in chain : " + (*it)->getName() + " linked to " + (*it)->getChild(i)->getName());
            }
        }
        actualidx++;
    }
}
 
}