pod_kernel.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 <cassert>
#include <sstream>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
 
#if BITPIT_ENABLE_MPI
#   include <mpi.h>
#endif
 
#include "bitpit_private_lapacke.hpp"
#include "bitpit_voloctree.hpp"
 
#include "pod_kernel.hpp"
 
namespace bitpit {


# if BITPIT_ENABLE_MPI
PODKernel::PODKernel(MPI_Comm comm)
# else
PODKernel::PODKernel()
# endif
:m_cellsVolume(1)
{
 
#if BITPIT_ENABLE_MPI
    m_communicator = MPI_COMM_NULL;
#endif  
 
    m_meshPOD = nullptr;
    m_meshmap = nullptr;
 
# if BITPIT_ENABLE_MPI
    initializeCommunicator(comm);
    MPI_Comm_size(m_communicator, &m_nProcs);
    MPI_Comm_rank(m_communicator, &m_rank);
#else
    m_rank = 0;
    m_nProcs = 1;
#endif
 
    setMapperDirty(true);
 
}

PODKernel::~PODKernel()
{
    clear();
}

void PODKernel::clear()
{
    clearMapper();
 
# if BITPIT_ENABLE_MPI
    freeCommunicator();
# endif
}

void PODKernel::setMesh(std::unique_ptr<VolumeKernel> &&mesh)
{
    m_meshPOD = std::move(mesh);
}

bitpit::VolumeKernel* PODKernel::getMesh()
{
    return m_meshPOD.get();
}

std::unique_ptr<VolumeKernel> PODKernel::readMesh(const pod::SnapshotFile &snap)
{
    int dumpBlock = (m_nProcs > 1) ? m_rank : -1;
    std::string filename = std::string(snap.directory) + "/" + std::string(snap.name) + ".mesh";
    IBinaryArchive binaryReader(filename, dumpBlock);
 
    std::unique_ptr<VolumeKernel> mesh = createMesh();
 
    mesh->restore(binaryReader.getStream());
 
    binaryReader.close();
 
    return mesh;
}

void PODKernel::restoreMesh(const pod::SnapshotFile &snap)
{
    m_meshPOD = readMesh(snap);
    evalCellsVolume();
}

void PODKernel::evalCellsVolume()
{
    m_cellsVolume.unsetKernel();
    m_cellsVolume.setStaticKernel(&m_meshPOD->getCells());
    for (Cell & cell : m_meshPOD->getCells()){
        long id = cell.getId();
        m_cellsVolume[id] = m_meshPOD->evalCellVolume(id);
    }
}

double PODKernel::getCellVolume(long id)
{
    return m_cellsVolume[id];
}

double PODKernel::getRawCellVolume(long rawIndex)
{
    return m_cellsVolume.rawAt(rawIndex);
}

void PODKernel::computeMapper(const VolumeKernel * mesh, bool fillInv)
{
    if (m_meshPOD == nullptr)
        throw std::runtime_error ("PODKernel: no pod mesh set in compute Mapper");
 
    if (mesh == nullptr)
        throw std::runtime_error ("PODKernel: no valid input mesh in compute Mapper");
 
    clearMapper();
 
    m_meshmap = _computeMapper(mesh, fillInv);
 
    setMapperDirty(false);
}

void PODKernel::adaptionPrepare(const std::vector<adaption::Info> & info)
{
    m_meshmap->adaptionPrepare(info, false);
    setMapperDirty(true);
}

void PODKernel::adaptionAlter(const std::vector<adaption::Info> & info, bool fillInv)
{
    m_meshmap->adaptionAlter(info, false, fillInv);
    setMapperDirty(false);
}

void PODKernel::adaptionCleanUp(const std::vector<adaption::Info> & info)
{
    BITPIT_UNUSED(info);
    m_meshmap->adaptionCleanup();
}

VolumeMapper* PODKernel::getMapper()
{
    return m_meshmap.get();
}
 

void PODKernel::clearMapper()
{
    m_meshmap.reset();
    setMapperDirty(true);
}

void PODKernel::setMapperDirty(bool dirty)
{
    m_dirtymap = dirty;
}

bool PODKernel::isMapperDirty()
{
    return m_dirtymap;
}
 
#if BITPIT_ENABLE_MPI
void PODKernel::initializeCommunicator(MPI_Comm communicator)
{
    // Communication can be set just once
    if (isCommunicatorSet())
        throw std::runtime_error ("PODKernel communicator can be set just once");
 
    // The communicator has to be valid
    if (communicator == MPI_COMM_NULL)
        throw std::runtime_error ("PODKernel communicator is not valid");
 
    // Create a copy of the user-specified communicator
    //
    // No library routine should use MPI_COMM_WORLD as the communicator;
    // instead, a duplicate of a user-specified communicator should always
    // be used.
    MPI_Comm_dup(communicator, &m_communicator);
}

MPI_Comm PODKernel::getCommunicator() const 
{
    return m_communicator;
}

bool PODKernel::isCommunicatorSet() const 
{
 
    return (getCommunicator() != MPI_COMM_NULL);
}

void PODKernel::freeCommunicator()
{
    if (!isCommunicatorSet()) 
        return;
 
    int finalizedCalled;
    MPI_Finalized(&finalizedCalled);
    if (finalizedCalled)
        return;
 
    MPI_Comm_free(&m_communicator);
}
#endif
 
}