volume_mapper.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 "volume_mapper.hpp"
 
namespace bitpit {


#if BITPIT_ENABLE_MPI
VolumeMapper::VolumeMapper(const VolumeKernel *referencePatch, const VolumeKernel *mappedPatch, MPI_Comm communicator)
#else
VolumeMapper::VolumeMapper(const VolumeKernel *referencePatch, const VolumeKernel *mappedPatch)
#endif
    : m_referencePatch(referencePatch), m_mappedPatch(mappedPatch), m_mapping(1)
#if BITPIT_ENABLE_MPI
      , m_communicator(MPI_COMM_NULL)
#endif
{
#if BITPIT_ENABLE_MPI
    initializeCommunicator(communicator);
#endif
}

void VolumeMapper::clear()
{
    clearMapping();
    clearInverseMapping();
}

void VolumeMapper::clearMapping()
{
    if (!m_mapping.getKernel()) {
        return;
    }
 
    m_mapping.unsetKernel(true);
}

void VolumeMapper::clearInverseMapping()
{
    if (!m_inverseMapping.getKernel()) {
        return;
    }
 
    m_inverseMapping.unsetKernel(false);
}

const bitpit::VolumeKernel *VolumeMapper::getReferencePatch() const
{
    return m_referencePatch;
}

const bitpit::VolumeKernel *VolumeMapper::getMappedPatch() const
{
    return m_mappedPatch;
}

const bitpit::PiercedStorage<mapping::Info> & VolumeMapper::getMapping() const
{
    return m_mapping;
}

const bitpit::PiercedStorage<mapping::Info> & VolumeMapper::getInverseMapping() const
{
    return m_inverseMapping;
}

void VolumeMapper::initialize(bool fillInverse)
{
    clear();
 
    _mapMeshes(fillInverse);
}
 
#if BITPIT_ENABLE_MPI
void VolumeMapper::initializeCommunicator(MPI_Comm communicator)
{
    // Communication can be set just once
    if (isCommunicatorSet()) {
        throw std::runtime_error ("VolumeMapper communicator can be set just once");
    }
 
    // The communicator has to be valid
    if (communicator == MPI_COMM_NULL) {
        throw std::runtime_error ("VolumeMapper 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);
 
    // Initialize parallel information
    MPI_Comm_size(m_communicator, &m_nProcs);
    MPI_Comm_rank(m_communicator, &m_rank);
}

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

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

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