lineunstructured.cpp

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit 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.
 *
 *  bitpit 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 bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
#include "bitpit_common.hpp"
 
#include "lineunstructured.hpp"
 
namespace bitpit {
 
#if BITPIT_ENABLE_MPI==1
LineUnstructured::LineUnstructured(MPI_Comm communicator)
    : LineKernel(communicator, 1, ADAPTION_MANUAL, PARTITIONING_ENABLED)
#else
LineUnstructured::LineUnstructured()
    : LineKernel(ADAPTION_MANUAL)
#endif
{
}
 
#if BITPIT_ENABLE_MPI==1
LineUnstructured::LineUnstructured(int dimension, MPI_Comm communicator)
    : LineKernel(PatchManager::AUTOMATIC_ID, dimension, communicator, 1, ADAPTION_MANUAL, PARTITIONING_ENABLED)
#else
LineUnstructured::LineUnstructured(int dimension)
    : LineKernel(PatchManager::AUTOMATIC_ID, dimension, ADAPTION_MANUAL)
#endif
{
}
 
#if BITPIT_ENABLE_MPI==1
LineUnstructured::LineUnstructured(int id, int dimension, MPI_Comm communicator)
    : LineKernel(id, dimension, communicator, 1, ADAPTION_MANUAL, PARTITIONING_ENABLED)
#else
LineUnstructured::LineUnstructured(int id, int dimension)
    : LineKernel(id, dimension, ADAPTION_MANUAL)
#endif
{
}
 
#if BITPIT_ENABLE_MPI==1
LineUnstructured::LineUnstructured(std::istream &stream, MPI_Comm communicator)
    : LineKernel(communicator, 1, ADAPTION_MANUAL, PARTITIONING_ENABLED)
#else
LineUnstructured::LineUnstructured(std::istream &stream)
    : LineKernel(ADAPTION_MANUAL)
#endif
{
    // Restore the patch
    restore(stream);
}
 
std::unique_ptr<PatchKernel> LineUnstructured::clone() const
{
    return std::unique_ptr<LineUnstructured>(new LineUnstructured(*this));
}
 
int LineUnstructured::_getDumpVersion() const
{
    const int DUMP_VERSION = 1;
 
    return DUMP_VERSION;
}
 
void LineUnstructured::_dump(std::ostream &stream) const
{
#if BITPIT_ENABLE_MPI==1
    // Dump works only for serial calculations
    if (getProcessorCount() != 1) {
        throw std::runtime_error ("Dump of lineunstructured is implemented only for serial calculations.");
    }
#endif
 
    // Save the vertices
    dumpVertices(stream);
 
    // Save the cells
    dumpCells(stream);
 
    // Save the interfaces
    dumpInterfaces(stream);
}
 
void LineUnstructured::_restore(std::istream &stream)
{
#if BITPIT_ENABLE_MPI==1
    // Restore works only for serial calculations
    if (getProcessorCount() != 1) {
        throw std::runtime_error ("Restore of lineunstructured is implemented only for serial calculations.");
    }
#endif
 
    // Restore the vertices
    restoreVertices(stream);
 
    // Restore the cells
    restoreCells(stream);
 
    // Restore the interfaces
    restoreInterfaces(stream);
}
 
long LineUnstructured::locatePoint(const std::array<double, 3> &point) const
{
    BITPIT_UNUSED(point);
 
    throw std::runtime_error ("The function 'locatePoint' is not implemented yet");
 
    return false;
}
 
unsigned short LineUnstructured::importDGF(const std::string &dgf_name, int PIDOffset, bool PIDSquash)
{
    // ====================================================================== //
    // VARIABLES DECLARATION                                                  //
    // ====================================================================== //
 
    // Local variables
    DGFObj                                                      dgf_in(dgf_name);
    int                                                         nV = 0, nS = 0;
    long                                                        vcount, idx;
    std::vector<std::array<double, 3>>                          vertex_list;
    std::vector<std::vector<int>>                               simplex_list;
    std::vector<int>                                            simplex_PID;
    std::vector<long>                                           vertex_map;
    std::vector<long>                                           connect;
 
    // Counters
    std::vector<std::array<double, 3>>::const_iterator          v_, ve_;
    std::vector<std::vector<int>>::iterator                     c_, ce_;
    std::vector<int>::iterator                                  i_, ie_;
    std::vector<long>::iterator                                 j_, je_;
 
    // ====================================================================== //
    // IMPORT DATA                                                            //
    // ====================================================================== //
 
    // Read vertices and cells from DGF file
    dgf_in.load(nV, nS, vertex_list, simplex_list, simplex_PID);
 
    // Add vertices
    ve_ = vertex_list.cend();
    vcount = 0;
    vertex_map.resize(nV);
    for (v_ = vertex_list.cbegin(); v_ != ve_; ++v_) {
        idx = addVertex(*v_)->getId();
        vertex_map[vcount] = idx;
        ++vcount;
    } //next v_
 
    // Update connectivity infos
    ce_ = simplex_list.end();
    for (c_ = simplex_list.begin(); c_ != ce_; ++c_) {
        ie_ = c_->end();
        for (i_ = c_->begin(); i_ != ie_; ++i_) {
            *i_ = vertex_map[*i_];
        } //next i_
    } //next c_
 
    // Add cells
    int k;
    for (c_ = simplex_list.begin(), k = 0; c_ != ce_; ++c_, ++k) {
        // Create cell
        i_ = c_->begin();
        connect.resize(c_->size(), Vertex::NULL_ID);
        je_ = connect.end();
        for (j_ = connect.begin(); j_ != je_; ++j_) {
            *j_ = *i_;
            ++i_;
        } //next j_
        CellIterator cellIterator = addCell(getDGFFacetType(c_->size()), connect);
 
        // Set cell PID
        int cellPID = PIDOffset;
        if (!PIDSquash) {
            cellPID += simplex_PID[k];
        }
 
        cellIterator->setPID(cellPID);
    } //next c_
 
    return 0;
}
 
unsigned short LineUnstructured::exportDGF(const std::string &dgf_name)
{
    // ====================================================================== //
    // VARIABLES DECLARATION                                                  //
    // ====================================================================== //
 
    // Local variables
    DGFObj                                                      dgf_in(dgf_name);
    int                                                         nV = getVertexCount(), nS = getCellCount();
    int                                                         v, nv;
    long                                                        vcount, ccount, idx;
    std::vector<std::array<double, 3>>                          vertex_list(nV);
    std::vector<std::vector<int>>                               simplex_list(nS);
    std::unordered_map<long, long>                              vertex_map;
 
    // Counters
    VertexIterator                                              v_, ve_;
    CellIterator                                                c_, ce_;
 
    // ====================================================================== //
    // EXPORT DATA                                                            //
    // ====================================================================== //
 
    // Create vertex list
    ve_ = vertexEnd();
    vcount = 0;
    for (v_ = vertexBegin(); v_ != ve_; ++v_) {
        idx = v_->getId();
        vertex_list[vcount] = v_->getCoords();
        vertex_map[idx] = vcount;
        ++vcount;
    } //next v_
 
    // Add cells
    ce_ = cellEnd();
    ccount = 0;
    for (c_ = cellBegin(); c_ != ce_; ++c_) {
        ConstProxyVector<long> cellVertexIds = c_->getVertexIds();
        nv = cellVertexIds.size();
        simplex_list[ccount].resize(nv);
        for (v = 0; v < nv; ++v) {
            simplex_list[ccount][v] = vertex_map[cellVertexIds[v]];
        } //next v
        ++ccount;
    } //next c_
 
    // Read vertices and cells from DGF file
    dgf_in.save(nV, nS, vertex_list, simplex_list);
 
    return 0;
}
 
ElementType LineUnstructured::getDGFFacetType(int nFacetVertices)
{
    switch(nFacetVertices) {
 
    case 1:
        return ElementType::VERTEX;
 
    case 2:
        return ElementType::LINE;
 
    default:
        return ElementType::UNDEFINED;
 
    }
}
 
}