GenericSelection.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 "MeshSelection.hpp"
 
namespace mimmo {
 
GenericSelection::GenericSelection(){
    m_type = SelectionType::UNDEFINED;
    m_topo = 1; /*default to surface geometry*/
    m_dual = false; /*default to exact selection*/
};
 
GenericSelection::~GenericSelection(){
    m_subpatch.reset();
};
 
GenericSelection::GenericSelection(const GenericSelection & other):BaseManipulation(other){
    m_type = other.m_type;
    m_topo = other.m_topo;
    m_dual = other.m_dual;
};
 
GenericSelection & GenericSelection::operator=(const GenericSelection & other){
    *(static_cast<BaseManipulation *>(this)) = *(static_cast<const BaseManipulation * >(&other));
    m_type = other.m_type;
    m_topo = other.m_topo;
    m_dual = other.m_dual;
    /*m_subpatch is not copied and it is obtained in execution*/
    return *this;
};
 
void GenericSelection::swap(GenericSelection & x) noexcept
{
    std::swap(m_type, x.m_type);
    std::swap(m_topo, x.m_topo);
    std::swap(m_dual, x.m_dual);
    BaseManipulation::swap(x);
}
 
void
GenericSelection::buildPorts(){
 
    bool built = true;
 
    built = (built && createPortIn<mimmo::MimmoSharedPointer<MimmoObject>, GenericSelection>(this, &GenericSelection::setGeometry, M_GEOM, true));
    built = (built && createPortIn<bool, GenericSelection>(this, &GenericSelection::setDual,M_VALUEB));
 
    built = (built && createPortOut<mimmo::MimmoSharedPointer<MimmoObject>, GenericSelection>(this, &GenericSelection::getPatch,M_GEOM));
    built = (built && createPortOut<livector1D, GenericSelection>(this, &GenericSelection::constrainedBoundary, M_VECTORLI));
    m_arePortsBuilt = built;
};
 
 
SelectionType
GenericSelection::whichMethod(){
    return    m_type;
};
 
mimmo::MimmoSharedPointer<MimmoObject>
GenericSelection::getPatch(){
    return    m_subpatch;
};
 
const mimmo::MimmoSharedPointer<MimmoObject>
GenericSelection::getPatch() const{
    return    m_subpatch;
};
 
void
GenericSelection::setGeometry( mimmo::MimmoSharedPointer<MimmoObject> target){
    if(target == nullptr)  return;
    m_geometry = target;
    /*set topology informations*/
    m_topo = target->getType();
 
};
 
 
void
GenericSelection::setDual(bool flag ){
    m_dual = flag;
}
 
bool
GenericSelection::isDual(){
    return m_dual;
};
 
livector1D
GenericSelection::constrainedBoundary(){
 
    if(getGeometry() == nullptr || getPatch() == nullptr)    return livector1D(0);
    std::unordered_map<long, std::set<int> > survivors;
 
    auto daughterBCells  = getPatch()->extractBoundaryFaceCellID(true);
    auto motherBCells = getGeometry()->extractBoundaryFaceCellID(true);
 
    //save all those daughter boundary faces not included in mother pot
    for(const auto & sT : daughterBCells){
        if(motherBCells.count(sT.first) > 0){
            for(const auto & val: sT.second){
                if(motherBCells[sT.first].count(val) > 0)   continue;
                survivors[sT.first].insert(val);
            }
        }else{
            survivors[sT.first] = daughterBCells[sT.first];
        }
    }
    motherBCells.clear();
    daughterBCells.clear();
 
    //get vertex of the cleaned daughter boundary.
    std::unordered_set<long> containerVert;
    containerVert.reserve(getPatch()->getPatch()->getVertexCount());
    for(const auto & sT  :survivors){
        const bitpit::Cell & cell = getPatch()->getPatch()->getCell(sT.first);
        for(const auto & val: sT.second){
            bitpit::ConstProxyVector<long> faceVertIds = cell.getFaceVertexIds(val);
            containerVert.insert(faceVertIds.begin(), faceVertIds.end());
        }
    }
    //move up in livector1D container.
    livector1D result;
    result.reserve(containerVert.size());
    result.insert(result.end(), containerVert.begin(), containerVert.end());
 
    return result;
};
 
 
void
GenericSelection::execute(){
    if(getGeometry() == nullptr) {
        (*m_log)<<m_name + " : nullptr pointer to target geometry found"<<std::endl;
        throw std::runtime_error (m_name + " : nullptr pointer to target geometry found");
    }
 
    m_subpatch.reset();
 
// extract all the interior cell satisfying the extraction criterium.
    livector1D extracted = extractSelection();
 
    /*Create subpatch.*/
    mimmo::MimmoSharedPointer<MimmoObject> temp(new MimmoObject(m_topo));
    
    /* Set the same tolerance of the mother geoemtry*/
    temp->setTolerance(getGeometry()->getTolerance());
 
    if (m_topo != 3){
 
        livector1D vertExtracted = getGeometry()->getVertexFromCellList(extracted);
        for(const auto & idV : vertExtracted){
            temp->addVertex(getGeometry()->getVertexCoords(idV), idV);
        }
 
        int rank;
        for(const auto & idCell : extracted){
            bitpit::Cell & cell = getGeometry()->getPatch()->getCell(idCell);
            rank = -1;
#if MIMMO_ENABLE_MPI
            rank = getGeometry()->getPatch()->getCellRank(idCell);
#endif
            temp->addCell(cell, idCell, rank);
        }
 
    }else{
 
        for(const auto & idV : extracted){
            temp->addVertex(getGeometry()->getVertexCoords(idV),idV);
        }
 
    }
 
    auto originalmap = getGeometry()->getPIDTypeListWNames();
    auto currentPIDmap = temp->getPIDTypeList();
    for(const auto & val: currentPIDmap){
        temp->setPIDName(val, originalmap[val]);
    }
    m_subpatch = temp;
 
    // Clean and Update selection patch. This will update even parallel structures if needed.
    m_subpatch->cleanGeometry();
    m_subpatch->update();
 
};
 
void
GenericSelection::plotOptionalResults(){
 
     write(getPatch());
 
}
 
}